diff --git a/Cargo.lock b/Cargo.lock
index f48897ce2b..ef51a2e35e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1102,6 +1102,17 @@ dependencies = [
  "melior",
 ]
 
+[[package]]
+name = "bolt-verifier-runtime"
+version = "0.1.0"
+dependencies = [
+ "jolt-field",
+ "jolt-poly",
+ "jolt-sumcheck",
+ "jolt-transcript",
+ "serde",
+]
+
 [[package]]
 name = "borsh"
 version = "1.6.0"
@@ -2902,6 +2913,7 @@ dependencies = [
  "ark-bn254",
  "ark-serialize 0.5.0",
  "bolt",
+ "bolt-verifier-runtime",
  "common",
  "jolt-core",
  "jolt-dory",
@@ -3322,6 +3334,7 @@ dependencies = [
 name = "jolt-verifier"
 version = "0.0.0"
 dependencies = [
+ "bolt-verifier-runtime",
  "jolt-dory",
  "jolt-field",
  "jolt-lookup-tables",
@@ -3329,7 +3342,6 @@ dependencies = [
  "jolt-poly",
  "jolt-sumcheck",
  "jolt-transcript",
- "serde",
  "tracing",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 3fc0ac5db7..d37ea39a9b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,6 +41,7 @@ members = [
   "crates/jolt-prover",
   "crates/jolt-verifier",
   "crates/jolt-equivalence",
+  "crates/bolt-verifier-runtime",
   "crates/jolt-profiling",
   "crates/jolt-field",
   "jolt-core",
@@ -393,6 +394,7 @@ jolt-sumcheck = { path = "./crates/jolt-sumcheck" }
 jolt-r1cs = { path = "./crates/jolt-r1cs" }
 jolt-witness = { path = "./crates/jolt-witness" }
 bolt = { path = "./crates/bolt" }
+bolt-verifier-runtime = { path = "./crates/bolt-verifier-runtime" }
 jolt-kernels = { path = "./crates/jolt-kernels" }
 jolt-prover = { path = "./crates/jolt-prover" }
 jolt-verifier = { path = "./crates/jolt-verifier" }
diff --git a/crates/bolt-verifier-runtime/Cargo.toml b/crates/bolt-verifier-runtime/Cargo.toml
new file mode 100644
index 0000000000..c1c361fb1b
--- /dev/null
+++ b/crates/bolt-verifier-runtime/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "bolt-verifier-runtime"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+description = "Protocol-generic runtime helpers for Bolt-generated verifier crates"
+repository = "https://github.com/a16z/jolt"
+
+[lints]
+workspace = true
+
+[dependencies]
+jolt-field.workspace = true
+jolt-poly.workspace = true
+jolt-sumcheck.workspace = true
+jolt-transcript.workspace = true
+serde.workspace = true
diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs
new file mode 100644
index 0000000000..ed1deef9bc
--- /dev/null
+++ b/crates/bolt-verifier-runtime/src/lib.rs
@@ -0,0 +1,2520 @@
+#![expect(
+    clippy::too_many_arguments,
+    reason = "generated verifier helpers mirror staged protocol ABIs"
+)]
+
+use std::collections::BTreeMap;
+use std::fmt;
+use std::marker::PhantomData;
+
+use jolt_field::{Field, Fr, MulPow2};
+use jolt_poly::{
+    lagrange::{lagrange_evals, lagrange_kernel_eval},
+    EqPlusOnePolynomial, EqPolynomial, LtPolynomial,
+};
+use jolt_sumcheck::{
+    CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier,
+};
+use jolt_transcript::{Label, Transcript};
+use serde::Serialize;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct StageParams {
+    pub field: &'static str,
+    pub pcs: &'static str,
+    pub transcript: &'static str,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct TypedPlanSymbol<Tag> {
+    symbol: &'static str,
+    _tag: PhantomData<fn() -> Tag>,
+}
+
+impl<Tag> TypedPlanSymbol<Tag> {
+    pub const fn new(symbol: &'static str) -> Self {
+        Self {
+            symbol,
+            _tag: PhantomData,
+        }
+    }
+
+    pub fn as_str(self) -> &'static str {
+        self.symbol
+    }
+}
+
+impl<Tag> fmt::Debug for TypedPlanSymbol<Tag> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_tuple("TypedPlanSymbol")
+            .field(&self.symbol)
+            .finish()
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct KernelPlan {
+    pub symbol: &'static str,
+    pub relation: &'static str,
+    pub kind: &'static str,
+    pub backend: &'static str,
+    pub abi: &'static str,
+}
+
+pub trait ProtocolRelation: Copy + Eq + fmt::Debug + 'static {}
+
+impl<T: Copy + Eq + fmt::Debug + 'static> ProtocolRelation for T {}
+
+pub trait VerifierProgramSlot: Copy + Eq + fmt::Debug + 'static {}
+
+impl<T: Copy + Eq + fmt::Debug + 'static> VerifierProgramSlot for T {}
+
+pub trait VerifierProgramCheckpoint: Copy + Eq + fmt::Debug + 'static {}
+
+impl<T: Copy + Eq + fmt::Debug + 'static> VerifierProgramCheckpoint for T {}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum VerifierProgramStepKind {
+    ReceiveCommitments,
+    VerifySumcheckStage,
+    VerifyPcsOpening,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct VerifierProgramStepPlan<S: VerifierProgramSlot> {
+    pub kind: VerifierProgramStepKind,
+    pub slot: S,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum VerifierEvaluationPolicy {
+    Skip,
+    VerifyIfPresent,
+    Required,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct VerifierTarget<C: VerifierProgramCheckpoint> {
+    pub checkpoint: C,
+    pub evaluation: VerifierEvaluationPolicy,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct VerifierTargetPlan<C: VerifierProgramCheckpoint> {
+    pub target: VerifierTarget<C>,
+    pub step_count: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct VerifierProgramPlan<S: VerifierProgramSlot, C: VerifierProgramCheckpoint> {
+    pub steps: &'static [VerifierProgramStepPlan<S>],
+    pub targets: &'static [VerifierTargetPlan<C>],
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum VerifierProgramError<S: VerifierProgramSlot, T: Copy + Eq + fmt::Debug + 'static> {
+    MissingTarget {
+        target: T,
+    },
+    InvalidStepCount {
+        target: T,
+        step_count: usize,
+        total_steps: usize,
+    },
+    MissingArtifact {
+        slot: S,
+    },
+    UnsupportedStep {
+        step: VerifierProgramStepPlan<S>,
+        reason: &'static str,
+    },
+}
+
+impl<S: VerifierProgramSlot, C: VerifierProgramCheckpoint> VerifierProgramPlan<S, C> {
+    pub fn steps_for(
+        &self,
+        target: VerifierTarget<C>,
+    ) -> Result<&'static [VerifierProgramStepPlan<S>], VerifierProgramError<S, VerifierTarget<C>>>
+    {
+        let target_plan = self
+            .targets
+            .iter()
+            .find(|plan| plan.target == target)
+            .ok_or(VerifierProgramError::MissingTarget { target })?;
+        let step_count = target_plan.step_count;
+        if step_count > self.steps.len() {
+            return Err(VerifierProgramError::InvalidStepCount {
+                target,
+                step_count,
+                total_steps: self.steps.len(),
+            });
+        }
+        Ok(&self.steps[..step_count])
+    }
+}
+
+pub fn execute_verifier_program<S, C, E>(
+    program: &VerifierProgramPlan<S, C>,
+    target: VerifierTarget<C>,
+    mut execute_step: impl FnMut(VerifierProgramStepPlan<S>) -> Result<(), E>,
+) -> Result<(), E>
+where
+    S: VerifierProgramSlot,
+    C: VerifierProgramCheckpoint,
+    E: From<VerifierProgramError<S, VerifierTarget<C>>>,
+{
+    for step in program.steps_for(target).map_err(E::from)? {
+        execute_step(*step)?;
+    }
+    Ok(())
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TranscriptSqueezeKind {
+    ChallengeScalar,
+    ChallengeVector,
+    Scalar,
+}
+
+impl TranscriptSqueezeKind {
+    pub fn is_scalar(self) -> bool {
+        matches!(self, Self::ChallengeScalar | Self::Scalar)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TranscriptSqueezePlan {
+    pub symbol: &'static str,
+    pub label: &'static str,
+    pub kind: TranscriptSqueezeKind,
+    pub count: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TranscriptAbsorbBytesPlan {
+    pub symbol: &'static str,
+    pub label: &'static str,
+    pub payload: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ProgramStepKind {
+    TranscriptSqueeze,
+    TranscriptAbsorbBytes,
+    SumcheckDriver,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ProgramStepPlan {
+    pub kind: ProgramStepKind,
+    pub symbol: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ClaimKind {
+    Committed,
+    Virtual,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PcsProofMode {
+    Open,
+    Verify,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct OpeningInputPlan {
+    pub symbol: &'static str,
+    pub source_stage: &'static str,
+    pub source_claim: &'static str,
+    pub oracle: &'static str,
+    pub domain: &'static str,
+    pub point_arity: usize,
+    pub claim_kind: ClaimKind,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct FieldConstantPlan {
+    pub symbol: &'static str,
+    pub field: &'static str,
+    pub value: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FieldExprKind {
+    OpeningEval,
+    Add,
+    Sub,
+    Mul,
+    Sum,
+    Product,
+    Neg,
+    Pow(usize),
+    LagrangeBasisEval(i64, usize, usize),
+    LagrangeKernelEval(i64, usize),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct FieldExprPlan {
+    pub symbol: &'static str,
+    pub kind: FieldExprKind,
+    pub operands: &'static [&'static str],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ScalarExprKind {
+    FieldVectorSum,
+    FieldVectorProduct,
+    StructuredPolynomial {
+        polynomial: StructuredPolynomialKind,
+        x_point: StructuredPolynomialPointTransform,
+        y_point: StructuredPolynomialPointTransform,
+    },
+    PowerStridedWeightedSum {
+        row_count: usize,
+        power_stride: usize,
+        value_term_offsets: &'static [usize],
+        shared_term_offsets: &'static [usize],
+        row_term_offsets: &'static [usize],
+    },
+    PointElement {
+        index: usize,
+    },
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ScalarExprPlan {
+    pub symbol: &'static str,
+    pub kind: ScalarExprKind,
+    pub operands: &'static [&'static str],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SumcheckClaimPlan<R: ProtocolRelation> {
+    pub symbol: &'static str,
+    pub stage: &'static str,
+    pub domain: &'static str,
+    pub num_rounds: usize,
+    pub degree: usize,
+    pub claim: &'static str,
+    pub kernel: Option<&'static str>,
+    pub relation: Option<R>,
+    pub claim_value: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SumcheckBatchPlan {
+    pub symbol: &'static str,
+    pub stage: &'static str,
+    pub proof_slot: &'static str,
+    pub policy: &'static str,
+    pub count: usize,
+    pub claim_operands: &'static [&'static str],
+    pub claim_label: &'static str,
+    pub round_label: &'static str,
+    pub round_schedule: &'static [usize],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SumcheckDriverPlan<R: ProtocolRelation> {
+    pub symbol: &'static str,
+    pub stage: &'static str,
+    pub proof_slot: &'static str,
+    pub kernel: Option<&'static str>,
+    pub relation: Option<R>,
+    pub batch: &'static str,
+    pub policy: &'static str,
+    pub round_schedule: &'static [usize],
+    pub claim_label: &'static str,
+    pub round_label: &'static str,
+    pub num_rounds: usize,
+    pub degree: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SumcheckInstanceResultPlan<R: ProtocolRelation> {
+    pub symbol: &'static str,
+    pub source: &'static str,
+    pub claim: &'static str,
+    pub relation: R,
+    pub index: usize,
+    pub point_arity: usize,
+    pub num_rounds: usize,
+    pub round_offset: usize,
+    pub point_order: SumcheckPointOrder,
+    pub degree: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SumcheckPointOrder {
+    AsIs,
+    Reverse,
+    RelationLocal,
+}
+
+impl SumcheckPointOrder {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::AsIs => "as_is",
+            Self::Reverse => "reverse",
+            Self::RelationLocal => "relation_local",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StructuredPolynomialPointOrder {
+    AsIs,
+    Reverse,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StructuredPolynomialPointSegment {
+    Full,
+    Prefix,
+    Suffix,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StructuredPolynomialPointLength {
+    Full,
+    XPoint,
+    YPoint,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct StructuredPolynomialPointPlan {
+    pub source: &'static str,
+    pub segment: StructuredPolynomialPointSegment,
+    pub length: StructuredPolynomialPointLength,
+    pub order: StructuredPolynomialPointOrder,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct StructuredPolynomialPointTransform {
+    pub segment: StructuredPolynomialPointSegment,
+    pub length: StructuredPolynomialPointLength,
+    pub order: StructuredPolynomialPointOrder,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StructuredPolynomialKind {
+    Eq,
+    EqPlusOne,
+    Lt,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct RelationOutputPlan<R: ProtocolRelation> {
+    pub relation: R,
+    pub local_scalars: &'static [&'static str],
+    pub expected_output: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SumcheckEvalPlan {
+    pub symbol: &'static str,
+    pub source: &'static str,
+    pub name: &'static str,
+    pub index: usize,
+    pub oracle: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PointExprKind {
+    Zero { field: &'static str, arity: usize },
+    Slice { offset: usize, length: usize },
+    Concat { layout: &'static str, arity: usize },
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PointExprPlan {
+    pub symbol: &'static str,
+    pub kind: PointExprKind,
+    pub operands: &'static [&'static str],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct OpeningClaimPlan {
+    pub symbol: &'static str,
+    pub oracle: &'static str,
+    pub domain: &'static str,
+    pub point_arity: usize,
+    pub claim_kind: ClaimKind,
+    pub point_source: &'static str,
+    pub eval_source: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum OpeningEqualityMode {
+    PointAndEval,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct OpeningClaimEqualityPlan {
+    pub symbol: &'static str,
+    pub mode: OpeningEqualityMode,
+    pub lhs: &'static str,
+    pub rhs: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct OpeningBatchPlan {
+    pub symbol: &'static str,
+    pub stage: &'static str,
+    pub proof_slot: &'static str,
+    pub policy: &'static str,
+    pub count: usize,
+    pub ordered_claims: &'static [&'static str],
+    pub claim_operands: &'static [&'static str],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct StageProgramPlan<R: ProtocolRelation> {
+    pub role: &'static str,
+    pub params: StageParams,
+    pub steps: &'static [ProgramStepPlan],
+    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
+    pub transcript_absorb_bytes: &'static [TranscriptAbsorbBytesPlan],
+    pub opening_inputs: &'static [OpeningInputPlan],
+    pub field_constants: &'static [FieldConstantPlan],
+    pub field_exprs: &'static [FieldExprPlan],
+    pub scalar_exprs: &'static [ScalarExprPlan],
+    pub kernels: &'static [KernelPlan],
+    pub claims: &'static [SumcheckClaimPlan<R>],
+    pub batches: &'static [SumcheckBatchPlan],
+    pub drivers: &'static [SumcheckDriverPlan<R>],
+    pub instance_results: &'static [SumcheckInstanceResultPlan<R>],
+    pub evals: &'static [SumcheckEvalPlan],
+    pub indexed_eval_families: &'static [NamedEvalFamilyPlan],
+    pub relation_outputs: &'static [RelationOutputPlan<R>],
+    pub point_exprs: &'static [PointExprPlan],
+    pub opening_claims: &'static [OpeningClaimPlan],
+    pub opening_equalities: &'static [OpeningClaimEqualityPlan],
+    pub opening_batches: &'static [OpeningBatchPlan],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct StageVerifierProgramPlan<R: ProtocolRelation> {
+    pub params: StageParams,
+    pub steps: &'static [ProgramStepPlan],
+    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
+    pub opening_inputs: &'static [OpeningInputPlan],
+    pub field_constants: &'static [FieldConstantPlan],
+    pub field_exprs: &'static [FieldExprPlan],
+    pub scalar_exprs: &'static [ScalarExprPlan],
+    pub claims: &'static [SumcheckClaimPlan<R>],
+    pub batches: &'static [SumcheckBatchPlan],
+    pub drivers: &'static [SumcheckDriverPlan<R>],
+    pub instance_results: &'static [SumcheckInstanceResultPlan<R>],
+    pub evals: &'static [SumcheckEvalPlan],
+    pub relation_outputs: &'static [RelationOutputPlan<R>],
+    pub point_exprs: &'static [PointExprPlan],
+    pub opening_claims: &'static [OpeningClaimPlan],
+    pub opening_equalities: &'static [OpeningClaimEqualityPlan],
+    pub opening_batches: &'static [OpeningBatchPlan],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct VerifierProgramPlanMinimal<R: ProtocolRelation> {
+    pub params: StageParams,
+    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
+    pub claims: &'static [SumcheckClaimPlan<R>],
+    pub batches: &'static [SumcheckBatchPlan],
+    pub drivers: &'static [SumcheckDriverPlan<R>],
+    pub instance_results: &'static [SumcheckInstanceResultPlan<R>],
+    pub evals: &'static [SumcheckEvalPlan],
+    pub opening_claims: &'static [OpeningClaimPlan],
+    pub opening_batches: &'static [OpeningBatchPlan],
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+pub struct StageNamedEval<F: Field> {
+    pub name: &'static str,
+    pub oracle: &'static str,
+    pub value: F,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct NamedScalar<F: Field> {
+    pub symbol: &'static str,
+    pub value: F,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct NamedPoint<'a, F: Field> {
+    pub symbol: &'static str,
+    pub point: &'a [F],
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct NamedFieldVector<F: Field> {
+    symbol: &'static str,
+    values: Vec<F>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputInputs<'a, F: Field> {
+    pub scalars: Vec<NamedScalar<F>>,
+    pub points: Vec<NamedPoint<'a, F>>,
+}
+
+impl<F: Field> Default for RelationOutputInputs<'_, F> {
+    fn default() -> Self {
+        Self {
+            scalars: Vec::new(),
+            points: Vec::new(),
+        }
+    }
+}
+
+impl<F: Field> RelationOutputInputs<'_, F> {
+    pub fn empty() -> Self {
+        Self::default()
+    }
+}
+
+pub fn select_named_scalars<F: Field>(
+    required_symbols: &[&'static str],
+    scalars: Vec<NamedScalar<F>>,
+) -> Result<Vec<NamedScalar<F>>, RuntimePlanError> {
+    required_symbols
+        .iter()
+        .map(|&symbol| {
+            scalars
+                .iter()
+                .find(|scalar| scalar.symbol == symbol)
+                .cloned()
+                .ok_or(RuntimePlanError::MissingValue { symbol })
+        })
+        .collect()
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct NamedEvalFamilyPlan {
+    pub symbol: &'static str,
+    pub evals: &'static [&'static str],
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct StageSumcheckOutput<F: Field> {
+    pub driver: &'static str,
+    pub point: Vec<F>,
+    pub evals: Vec<StageNamedEval<F>>,
+    pub proof: SumcheckProof<F>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct StageChallengeVector<F: Field> {
+    pub symbol: &'static str,
+    pub values: Vec<F>,
+}
+
+#[derive(Clone, Debug)]
+pub struct StageExecutionArtifacts<F: Field> {
+    pub challenge_vectors: Vec<StageChallengeVector<F>>,
+    pub sumchecks: Vec<StageSumcheckOutput<F>>,
+    pub opening_batches: Vec<&'static OpeningBatchPlan>,
+}
+
+impl<F: Field> Default for StageExecutionArtifacts<F> {
+    fn default() -> Self {
+        Self {
+            challenge_vectors: Vec::new(),
+            sumchecks: Vec::new(),
+            opening_batches: Vec::new(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct StageProof<F: Field> {
+    pub sumchecks: Vec<StageSumcheckOutput<F>>,
+}
+
+#[derive(Clone, Debug)]
+pub struct StageOpeningInputValue<F: Field> {
+    pub symbol: &'static str,
+    pub point: Vec<F>,
+    pub eval: F,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RuntimePlanError {
+    MissingBatch {
+        driver: &'static str,
+        batch: &'static str,
+    },
+    MissingClaim {
+        batch: &'static str,
+        claim: &'static str,
+    },
+    MissingValue {
+        symbol: &'static str,
+    },
+    InvalidInputLength {
+        input: &'static str,
+        expected: usize,
+        actual: usize,
+    },
+    InvalidProof {
+        driver: &'static str,
+        reason: &'static str,
+    },
+}
+
+#[macro_export]
+macro_rules! impl_runtime_plan_error_conversion {
+    ($error:ident) => {
+        impl From<$crate::RuntimePlanError> for $error {
+            fn from(error: $crate::RuntimePlanError) -> Self {
+                match error {
+                    $crate::RuntimePlanError::MissingBatch { driver, batch } => {
+                        Self::MissingBatch { driver, batch }
+                    }
+                    $crate::RuntimePlanError::MissingClaim { batch, claim } => {
+                        Self::MissingClaim { batch, claim }
+                    }
+                    $crate::RuntimePlanError::MissingValue { symbol } => {
+                        Self::MissingValue { symbol }
+                    }
+                    $crate::RuntimePlanError::InvalidInputLength {
+                        input,
+                        expected,
+                        actual,
+                    } => Self::InvalidInputLength {
+                        input,
+                        expected,
+                        actual,
+                    },
+                    $crate::RuntimePlanError::InvalidProof { driver, reason } => {
+                        Self::InvalidProof { driver, reason }
+                    }
+                }
+            }
+        }
+    };
+}
+
+pub trait SymbolPlan {
+    fn symbol(&self) -> &'static str;
+}
+
+impl SymbolPlan for TranscriptSqueezePlan {
+    fn symbol(&self) -> &'static str {
+        self.symbol
+    }
+}
+
+impl SymbolPlan for TranscriptAbsorbBytesPlan {
+    fn symbol(&self) -> &'static str {
+        self.symbol
+    }
+}
+
+impl SymbolPlan for SumcheckBatchPlan {
+    fn symbol(&self) -> &'static str {
+        self.symbol
+    }
+}
+
+impl<R: ProtocolRelation> SymbolPlan for SumcheckClaimPlan<R> {
+    fn symbol(&self) -> &'static str {
+        self.symbol
+    }
+}
+
+impl<R: ProtocolRelation> SymbolPlan for SumcheckDriverPlan<R> {
+    fn symbol(&self) -> &'static str {
+        self.symbol
+    }
+}
+
+impl SymbolPlan for OpeningClaimPlan {
+    fn symbol(&self) -> &'static str {
+        self.symbol
+    }
+}
+
+pub trait SumcheckClaimInfo: SymbolPlan {
+    fn num_rounds(&self) -> usize;
+    fn claim_value(&self) -> &'static str;
+}
+
+impl<R: ProtocolRelation> SumcheckClaimInfo for SumcheckClaimPlan<R> {
+    fn num_rounds(&self) -> usize {
+        self.num_rounds
+    }
+
+    fn claim_value(&self) -> &'static str {
+        self.claim_value
+    }
+}
+
+pub trait SumcheckDriverInfo: SymbolPlan {
+    fn batch(&self) -> &'static str;
+    fn num_rounds(&self) -> usize;
+    fn degree(&self) -> usize;
+    fn round_label(&self) -> &'static str;
+}
+
+impl<R: ProtocolRelation> SumcheckDriverInfo for SumcheckDriverPlan<R> {
+    fn batch(&self) -> &'static str {
+        self.batch
+    }
+
+    fn num_rounds(&self) -> usize {
+        self.num_rounds
+    }
+
+    fn degree(&self) -> usize {
+        self.degree
+    }
+
+    fn round_label(&self) -> &'static str {
+        self.round_label
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct ValueStore<F: Field> {
+    scalars: Vec<(&'static str, F)>,
+    points: Vec<(&'static str, Vec<F>)>,
+    field_vectors: Vec<(&'static str, Vec<F>)>,
+}
+
+impl<F: Field> ValueStore<F> {
+    pub fn with_opening_inputs(
+        inputs: &[StageOpeningInputValue<F>],
+        expected_inputs: &[OpeningInputPlan],
+    ) -> Result<Self, RuntimePlanError> {
+        if inputs.len() != expected_inputs.len() {
+            return Err(RuntimePlanError::InvalidInputLength {
+                input: "opening_inputs",
+                expected: expected_inputs.len(),
+                actual: inputs.len(),
+            });
+        }
+        for expected in expected_inputs {
+            let matching_count = inputs
+                .iter()
+                .filter(|input| input.symbol == expected.symbol)
+                .count();
+            if matching_count != 1 {
+                return Err(RuntimePlanError::InvalidInputLength {
+                    input: expected.symbol,
+                    expected: 1,
+                    actual: matching_count,
+                });
+            }
+            if let Some(input) = inputs.iter().find(|input| input.symbol == expected.symbol) {
+                if input.point.len() != expected.point_arity {
+                    return Err(RuntimePlanError::InvalidInputLength {
+                        input: expected.symbol,
+                        expected: expected.point_arity,
+                        actual: input.point.len(),
+                    });
+                }
+            }
+        }
+        let mut store = Self::default();
+        for input in inputs {
+            store.insert_scalar(input.symbol, input.eval);
+            store.insert_point(input.symbol, input.point.clone());
+        }
+        Ok(store)
+    }
+
+    pub fn seed_constants(&mut self, constants: &[FieldConstantPlan]) {
+        for constant in constants {
+            self.insert_scalar(constant.symbol, F::from_u64(constant.value as u64));
+        }
+    }
+
+    pub fn observe_challenge_vector<E>(
+        &mut self,
+        plan: &TranscriptSqueezePlan,
+        values: &[F],
+        invalid_input_length: impl Fn(&'static str, usize, usize) -> E,
+    ) -> Result<(), E> {
+        self.insert_point(plan.symbol, values.to_vec());
+        if plan.kind.is_scalar() {
+            if values.len() != 1 {
+                return Err(invalid_input_length(plan.symbol, 1, values.len()));
+            }
+            self.insert_scalar(plan.symbol, values[0]);
+        }
+        Ok(())
+    }
+
+    pub fn observe_sumcheck_output<E, R: ProtocolRelation>(
+        &mut self,
+        instance_results: &[SumcheckInstanceResultPlan<R>],
+        evals: &[SumcheckEvalPlan],
+        output: &StageSumcheckOutput<F>,
+        normalize_point: impl Fn(&SumcheckInstanceResultPlan<R>, Vec<F>) -> Result<Vec<F>, E>,
+        invalid_input_length: impl Fn(&'static str, usize, usize) -> E,
+        missing_value: impl Fn(&'static str) -> E,
+    ) -> Result<(), E> {
+        self.insert_point(output.driver, output.point.clone());
+        for instance in instance_results
+            .iter()
+            .filter(|instance| instance.source == output.driver)
+        {
+            let end = instance.round_offset + instance.point_arity;
+            let point = output
+                .point
+                .get(instance.round_offset..end)
+                .ok_or_else(|| invalid_input_length(instance.symbol, end, output.point.len()))?
+                .to_vec();
+            self.insert_point(instance.symbol, normalize_point(instance, point)?);
+        }
+        for eval in evals.iter().filter(|eval| eval.source == output.driver) {
+            let value = output
+                .evals
+                .iter()
+                .find(|value| value.name == eval.name)
+                .ok_or_else(|| missing_value(eval.symbol))?
+                .value;
+            self.insert_scalar(eval.symbol, value);
+            self.insert_scalar(eval.name, value);
+        }
+        Ok(())
+    }
+
+    pub fn evaluate_available_points<E>(
+        &mut self,
+        point_exprs: &[PointExprPlan],
+        invalid_input_length: impl Fn(&'static str, usize, usize) -> E,
+    ) -> Result<(), E> {
+        loop {
+            let mut progress = 0usize;
+            for expr in point_exprs {
+                if self.try_point(expr.symbol).is_some() {
+                    continue;
+                }
+                let Some(point) = self.try_point_expr(expr, &invalid_input_length)? else {
+                    continue;
+                };
+                self.insert_point(expr.symbol, point);
+                progress += 1;
+            }
+            if progress == 0 {
+                return Ok(());
+            }
+        }
+    }
+
+    pub fn evaluate_available_field_exprs<E>(
+        &mut self,
+        field_exprs: &[FieldExprPlan],
+        evaluate: impl Fn(&FieldExprPlan, &[F]) -> Result<F, E>,
+    ) -> Result<(), E> {
+        loop {
+            let mut progress = 0usize;
+            for expr in field_exprs {
+                if self.try_scalar(expr.symbol).is_some() {
+                    continue;
+                }
+                let Some(operands) = self.try_field_expr_operands(expr) else {
+                    continue;
+                };
+                self.insert_scalar(expr.symbol, evaluate(expr, &operands)?);
+                progress += 1;
+            }
+            if progress == 0 {
+                return Ok(());
+            }
+        }
+    }
+
+    pub fn evaluate_available_exprs(
+        &mut self,
+        field_exprs: &[FieldExprPlan],
+        scalar_exprs: &[ScalarExprPlan],
+    ) -> Result<(), RuntimePlanError> {
+        loop {
+            let mut progress = 0usize;
+            for expr in field_exprs {
+                if self.try_scalar(expr.symbol).is_some() {
+                    continue;
+                }
+                let Some(operands) = self.try_field_expr_operands(expr) else {
+                    continue;
+                };
+                self.insert_scalar(expr.symbol, evaluate_field_expr(expr, &operands)?);
+                progress += 1;
+            }
+            for expr in scalar_exprs {
+                if self.try_scalar(expr.symbol).is_some() {
+                    continue;
+                }
+                let Some(operands) = self.try_scalar_expr_operands(expr) else {
+                    continue;
+                };
+                self.insert_scalar(expr.symbol, evaluate_scalar_expr(expr, &operands)?);
+                progress += 1;
+            }
+            if progress == 0 {
+                return Ok(());
+            }
+        }
+    }
+
+    pub fn evaluate_named_eval_families(
+        &mut self,
+        families: &[NamedEvalFamilyPlan],
+    ) -> Result<(), RuntimePlanError> {
+        for family in families {
+            if self.try_field_vector(family.symbol).is_some() {
+                continue;
+            }
+            let values = family
+                .evals
+                .iter()
+                .map(|eval| {
+                    self.try_scalar(eval)
+                        .ok_or(RuntimePlanError::MissingValue { symbol: eval })
+                })
+                .collect::<Result<Vec<_>, RuntimePlanError>>()?;
+            self.insert_field_vector(family.symbol, values);
+        }
+        Ok(())
+    }
+
+    pub fn verify_opening_equalities<E>(
+        &self,
+        opening_equalities: &[OpeningClaimEqualityPlan],
+        invalid_proof: impl Fn(&'static str, &'static str) -> E,
+        missing_value: impl Fn(&'static str) -> E,
+    ) -> Result<(), E> {
+        for equality in opening_equalities {
+            match equality.mode {
+                OpeningEqualityMode::PointAndEval => {
+                    if self.point_or(equality.lhs, &missing_value)?
+                        != self.point_or(equality.rhs, &missing_value)?
+                        || self.scalar_or(equality.lhs, &missing_value)?
+                            != self.scalar_or(equality.rhs, &missing_value)?
+                    {
+                        return Err(invalid_proof(
+                            equality.symbol,
+                            "opening claim equality failed",
+                        ));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub fn insert_scalar(&mut self, symbol: &'static str, value: F) {
+        if let Some((_, existing)) = self.scalars.iter_mut().find(|(name, _)| *name == symbol) {
+            *existing = value;
+        } else {
+            self.scalars.push((symbol, value));
+        }
+    }
+
+    pub fn insert_point(&mut self, symbol: &'static str, point: Vec<F>) {
+        if let Some((_, existing)) = self.points.iter_mut().find(|(name, _)| *name == symbol) {
+            *existing = point;
+        } else {
+            self.points.push((symbol, point));
+        }
+    }
+
+    pub fn insert_field_vector(&mut self, symbol: &'static str, values: Vec<F>) {
+        if let Some((_, existing)) = self
+            .field_vectors
+            .iter_mut()
+            .find(|(name, _)| *name == symbol)
+        {
+            *existing = values;
+        } else {
+            self.field_vectors.push((symbol, values));
+        }
+    }
+
+    pub fn scalar_or<E>(
+        &self,
+        symbol: &'static str,
+        missing_value: impl FnOnce(&'static str) -> E,
+    ) -> Result<F, E> {
+        self.try_scalar(symbol).ok_or_else(|| missing_value(symbol))
+    }
+
+    pub fn try_scalar(&self, symbol: &str) -> Option<F> {
+        self.scalars
+            .iter()
+            .find(|(name, _)| *name == symbol)
+            .map(|(_, value)| *value)
+    }
+
+    pub fn point_or<E>(
+        &self,
+        symbol: &'static str,
+        missing_value: impl FnOnce(&'static str) -> E,
+    ) -> Result<&[F], E> {
+        self.try_point(symbol).ok_or_else(|| missing_value(symbol))
+    }
+
+    pub fn try_point(&self, symbol: &str) -> Option<&[F]> {
+        self.points
+            .iter()
+            .find(|(name, _)| *name == symbol)
+            .map(|(_, point)| point.as_slice())
+    }
+
+    pub fn field_vector_or<E>(
+        &self,
+        symbol: &'static str,
+        missing_value: impl FnOnce(&'static str) -> E,
+    ) -> Result<&[F], E> {
+        self.try_field_vector(symbol)
+            .ok_or_else(|| missing_value(symbol))
+    }
+
+    pub fn try_field_vector(&self, symbol: &str) -> Option<&[F]> {
+        self.field_vectors
+            .iter()
+            .find(|(name, _)| *name == symbol)
+            .map(|(_, values)| values.as_slice())
+    }
+
+    fn try_field_expr_operands(&self, expr: &FieldExprPlan) -> Option<Vec<F>> {
+        expr.operands
+            .iter()
+            .map(|operand| self.try_scalar(operand))
+            .collect()
+    }
+
+    fn try_scalar_expr_operands(&self, expr: &ScalarExprPlan) -> Option<Vec<F>> {
+        match expr.kind {
+            ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => {
+                let [symbol] = expr.operands else {
+                    return Some(Vec::new());
+                };
+                self.try_field_vector(symbol).map(|values| values.to_vec())
+            }
+            ScalarExprKind::StructuredPolynomial { .. } => None,
+            ScalarExprKind::PowerStridedWeightedSum { .. } => expr
+                .operands
+                .iter()
+                .map(|operand| self.try_scalar(operand))
+                .collect(),
+            ScalarExprKind::PointElement { index } => {
+                let [symbol] = expr.operands else {
+                    return Some(Vec::new());
+                };
+                self.try_point(symbol)
+                    .map(|point| point.get(index).copied().into_iter().collect())
+            }
+        }
+    }
+
+    fn try_point_expr<E>(
+        &self,
+        expr: &PointExprPlan,
+        invalid_input_length: &impl Fn(&'static str, usize, usize) -> E,
+    ) -> Result<Option<Vec<F>>, E> {
+        match expr.kind {
+            PointExprKind::Zero { arity, .. } => Ok(Some(vec![F::from_u64(0); arity])),
+            PointExprKind::Slice { offset, length } => {
+                let [input] = expr.operands else {
+                    return Err(invalid_input_length(expr.symbol, 1, expr.operands.len()));
+                };
+                let Some(point) = self.try_point(input) else {
+                    return Ok(None);
+                };
+                let end = offset + length;
+                let point = point
+                    .get(offset..end)
+                    .ok_or_else(|| invalid_input_length(expr.symbol, end, point.len()))?
+                    .to_vec();
+                Ok(Some(point))
+            }
+            PointExprKind::Concat { arity, .. } => {
+                let mut point = Vec::with_capacity(arity);
+                for input in expr.operands {
+                    let Some(input) = self.try_point(input) else {
+                        return Ok(None);
+                    };
+                    point.extend_from_slice(input);
+                }
+                if point.len() != arity {
+                    return Err(invalid_input_length(expr.symbol, arity, point.len()));
+                }
+                Ok(Some(point))
+            }
+        }
+    }
+}
+
+pub fn find_plan<'a, T: SymbolPlan>(plans: &'a [T], symbol: &str) -> Option<&'a T> {
+    plans.iter().find(|plan| plan.symbol() == symbol)
+}
+
+pub fn find_batch<'a>(
+    batches: &'a [SumcheckBatchPlan],
+    driver: &'static str,
+    batch: &'static str,
+) -> Result<&'a SumcheckBatchPlan, RuntimePlanError> {
+    find_plan(batches, batch).ok_or(RuntimePlanError::MissingBatch { driver, batch })
+}
+
+pub fn batch_claims<'a, C: SymbolPlan>(
+    claims: &'a [C],
+    batch: &SumcheckBatchPlan,
+) -> Result<Vec<&'a C>, RuntimePlanError> {
+    batch
+        .claim_operands
+        .iter()
+        .copied()
+        .map(|symbol| {
+            find_plan(claims, symbol).ok_or(RuntimePlanError::MissingClaim {
+                batch: batch.symbol,
+                claim: symbol,
+            })
+        })
+        .collect()
+}
+
+pub fn batch_claim_values<C: SumcheckClaimInfo>(
+    claims: &[&C],
+    field_exprs: &[FieldExprPlan],
+    scalar_exprs: &[ScalarExprPlan],
+    store: &mut ValueStore<Fr>,
+) -> Result<Vec<Fr>, RuntimePlanError> {
+    claims
+        .iter()
+        .map(|claim| {
+            store.evaluate_available_exprs(field_exprs, scalar_exprs)?;
+            store.scalar_or(claim.claim_value(), |symbol| {
+                RuntimePlanError::MissingValue { symbol }
+            })
+        })
+        .collect()
+}
+
+pub fn verify_batched_sumcheck<T, E, C, D, Expected, Observe, MapSumcheck>(
+    driver: &'static D,
+    proof: &StageSumcheckOutput<Fr>,
+    claims: &'static [C],
+    batches: &'static [SumcheckBatchPlan],
+    field_exprs: &'static [FieldExprPlan],
+    scalar_exprs: &'static [ScalarExprPlan],
+    opening_inputs: &'static [OpeningInputPlan],
+    opening_claims: &'static [OpeningClaimPlan],
+    opening_batches: &'static [OpeningBatchPlan],
+    store: &mut ValueStore<Fr>,
+    transcript: &mut T,
+    expected_output: Expected,
+    observe_output: Observe,
+    map_sumcheck: MapSumcheck,
+) -> Result<StageSumcheckOutput<Fr>, E>
+where
+    T: Transcript<Challenge = Fr>,
+    E: From<RuntimePlanError>,
+    C: SumcheckClaimInfo,
+    D: SumcheckDriverInfo,
+    Expected: FnOnce(&ValueStore<Fr>, &[StageNamedEval<Fr>], &[Fr], &[Fr]) -> Result<Fr, E>,
+    Observe: FnOnce(&mut ValueStore<Fr>, &StageSumcheckOutput<Fr>) -> Result<(), E>,
+    MapSumcheck: FnOnce(&'static str, SumcheckError<Fr>) -> E,
+{
+    if proof.driver != driver.symbol() {
+        return Err(RuntimePlanError::InvalidProof {
+            driver: driver.symbol(),
+            reason: "driver symbol mismatch",
+        }
+        .into());
+    }
+    let batch = find_batch(batches, driver.symbol(), driver.batch())?;
+    let claims = batch_claims(claims, batch)?;
+    let input_claims = batch_claim_values(&claims, field_exprs, scalar_exprs, store)?;
+    for claim in &input_claims {
+        append_labeled_scalar(transcript, batch.claim_label, claim);
+    }
+    let batching_coeffs = transcript.challenge_vector(claims.len());
+    let claimed_sum = input_claims
+        .iter()
+        .zip(claims.iter())
+        .zip(&batching_coeffs)
+        .map(|((claim, plan), coefficient)| {
+            claim.mul_pow_2(driver.num_rounds() - plan.num_rounds()) * *coefficient
+        })
+        .sum::<Fr>();
+    let claim = SumcheckClaim::new(driver.num_rounds(), driver.degree(), claimed_sum);
+    let round_proofs = proof
+        .proof
+        .round_polynomials
+        .iter()
+        .map(|poly| CompressedLabeledRoundPoly::new(poly, driver.round_label().as_bytes()))
+        .collect::<Vec<_>>();
+    let output = SumcheckVerifier::verify_optimized(&claim, &round_proofs, transcript)
+        .map_err(|error| map_sumcheck(driver.symbol(), error))?;
+    if !proof.point.is_empty() && proof.point != output.point {
+        return Err(RuntimePlanError::InvalidProof {
+            driver: driver.symbol(),
+            reason: "batched point mismatch",
+        }
+        .into());
+    }
+    let expected = expected_output(store, &proof.evals, &output.point, &batching_coeffs)?;
+    if output.value != expected {
+        return Err(RuntimePlanError::InvalidProof {
+            driver: driver.symbol(),
+            reason: "batched output claim mismatch",
+        }
+        .into());
+    }
+    let verified = StageSumcheckOutput {
+        driver: driver.symbol(),
+        point: output.point,
+        evals: proof.evals.clone(),
+        proof: proof.proof.clone(),
+    };
+    observe_output(store, &verified)?;
+    append_opening_claims(
+        opening_inputs,
+        opening_claims,
+        opening_batches,
+        store,
+        transcript,
+        &verified.evals,
+        |batch, claim| RuntimePlanError::MissingClaim { batch, claim },
+        |symbol| RuntimePlanError::MissingValue { symbol },
+    )?;
+    Ok(verified)
+}
+
+pub fn eval_by_name<F: Field>(
+    evals: &[StageNamedEval<F>],
+    name: &'static str,
+) -> Result<F, RuntimePlanError> {
+    evals
+        .iter()
+        .find(|eval| eval.name == name)
+        .map(|eval| eval.value)
+        .ok_or(RuntimePlanError::MissingValue { symbol: name })
+}
+
+pub fn eval_family_values<F: Field>(
+    evals: &[StageNamedEval<F>],
+    family: &NamedEvalFamilyPlan,
+) -> Result<Vec<F>, RuntimePlanError> {
+    family
+        .evals
+        .iter()
+        .map(|&name| eval_by_name(evals, name))
+        .collect()
+}
+
+pub fn try_eval_family_values<F: Field>(
+    evals: &[StageNamedEval<F>],
+    family: &NamedEvalFamilyPlan,
+) -> Option<Vec<F>> {
+    family
+        .evals
+        .iter()
+        .map(|&name| {
+            evals
+                .iter()
+                .find(|eval| eval.name == name)
+                .map(|eval| eval.value)
+        })
+        .collect()
+}
+
+pub fn evaluate_relation_output<R: ProtocolRelation>(
+    plan: &RelationOutputPlan<R>,
+    field_exprs: &[FieldExprPlan],
+    scalar_exprs: &[ScalarExprPlan],
+    eval_families: &[NamedEvalFamilyPlan],
+    store: &ValueStore<Fr>,
+    instance_symbol: &'static str,
+    evals: &[StageNamedEval<Fr>],
+    local_scalars: &[NamedScalar<Fr>],
+    local_points: &[NamedPoint<'_, Fr>],
+    local_point: &[Fr],
+) -> Result<Fr, RuntimePlanError> {
+    let mut scratch = ScratchScalars::default();
+    for scalar in local_scalars {
+        scratch.insert(scalar.symbol, scalar.value);
+    }
+    for symbol in plan.local_scalars {
+        if !local_scalars.iter().any(|scalar| scalar.symbol == *symbol) {
+            return Err(RuntimePlanError::MissingValue { symbol });
+        }
+    }
+    for eval in evals {
+        scratch.insert(eval.name, eval.value);
+    }
+    let local_field_vectors = eval_families
+        .iter()
+        .filter_map(|family| {
+            try_eval_family_values(evals, family).map(|values| NamedFieldVector {
+                symbol: family.symbol,
+                values,
+            })
+        })
+        .collect::<Vec<_>>();
+    let context = RelationOutputContext {
+        instance_symbol,
+        local_points,
+        local_point,
+        local_field_vectors: &local_field_vectors,
+    };
+    evaluate_available_exprs_with_scratch(field_exprs, scalar_exprs, store, &mut scratch, context)?;
+    scratch
+        .scalar_or(store, plan.expected_output)
+        .ok_or(RuntimePlanError::MissingValue {
+            symbol: plan.expected_output,
+        })
+}
+
+pub fn evaluate_relation_output_for_instance<R: ProtocolRelation>(
+    relation_outputs: &[RelationOutputPlan<R>],
+    field_exprs: &[FieldExprPlan],
+    scalar_exprs: &[ScalarExprPlan],
+    eval_families: &[NamedEvalFamilyPlan],
+    store: &ValueStore<Fr>,
+    instance: &SumcheckInstanceResultPlan<R>,
+    evals: &[StageNamedEval<Fr>],
+    local_scalars: &[NamedScalar<Fr>],
+    local_points: &[NamedPoint<'_, Fr>],
+    local_point: &[Fr],
+) -> Result<Fr, RuntimePlanError> {
+    let relation_output = relation_outputs
+        .iter()
+        .find(|relation_output| relation_output.relation == instance.relation)
+        .ok_or(RuntimePlanError::InvalidProof {
+            driver: instance.symbol,
+            reason: "missing relation output for relation",
+        })?;
+    evaluate_relation_output(
+        relation_output,
+        field_exprs,
+        scalar_exprs,
+        eval_families,
+        store,
+        instance.symbol,
+        evals,
+        local_scalars,
+        local_points,
+        local_point,
+    )
+}
+
+pub fn evaluate_relation_output_batch<R, E, LocalInputs>(
+    driver: &SumcheckDriverPlan<R>,
+    batches: &[SumcheckBatchPlan],
+    claims: &[SumcheckClaimPlan<R>],
+    instance_results: &[SumcheckInstanceResultPlan<R>],
+    relation_outputs: &[RelationOutputPlan<R>],
+    field_exprs: &[FieldExprPlan],
+    scalar_exprs: &[ScalarExprPlan],
+    eval_families: &[NamedEvalFamilyPlan],
+    store: &ValueStore<Fr>,
+    evals: &[StageNamedEval<Fr>],
+    point: &[Fr],
+    batching_coeffs: &[Fr],
+    mut local_inputs: LocalInputs,
+) -> Result<Fr, E>
+where
+    R: ProtocolRelation,
+    E: From<RuntimePlanError>,
+    LocalInputs: for<'a> FnMut(
+        &SumcheckInstanceResultPlan<R>,
+        &RelationOutputPlan<R>,
+        &'a [Fr],
+    ) -> Result<RelationOutputInputs<'a, Fr>, E>,
+{
+    let batch = find_batch(batches, driver.symbol, driver.batch)?;
+    let claims = batch_claims(claims, batch)?;
+    let mut expected = Fr::from_u64(0);
+    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
+        let instance = instance_results
+            .iter()
+            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
+            .ok_or(RuntimePlanError::MissingClaim {
+                batch: batch.symbol,
+                claim: claim.symbol,
+            })?;
+        let relation_output = relation_outputs
+            .iter()
+            .find(|relation_output| relation_output.relation == instance.relation)
+            .ok_or(RuntimePlanError::InvalidProof {
+                driver: instance.symbol,
+                reason: "missing relation output for relation",
+            })?;
+        let local_point = point
+            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
+            .ok_or(RuntimePlanError::InvalidInputLength {
+                input: instance.symbol,
+                expected: instance.round_offset + instance.num_rounds,
+                actual: point.len(),
+            })?;
+        let inputs = local_inputs(instance, relation_output, local_point)?;
+        let value = evaluate_relation_output(
+            relation_output,
+            field_exprs,
+            scalar_exprs,
+            eval_families,
+            store,
+            instance.symbol,
+            evals,
+            &inputs.scalars,
+            &inputs.points,
+            local_point,
+        )?;
+        expected += *coefficient * value;
+    }
+    Ok(expected)
+}
+
+fn try_relation_output_x_point_source<'a>(
+    source: &'static str,
+    instance_symbol: &'static str,
+    local_points: &'a [NamedPoint<'a, Fr>],
+    local_point: &'a [Fr],
+    store: &'a ValueStore<Fr>,
+) -> Option<&'a [Fr]> {
+    local_points
+        .iter()
+        .find(|point| point.symbol == source)
+        .map(|point| point.point)
+        .or_else(|| (source == instance_symbol).then_some(local_point))
+        .or_else(|| store.try_point(source))
+}
+
+#[derive(Clone, Copy)]
+struct RelationOutputContext<'a> {
+    instance_symbol: &'static str,
+    local_points: &'a [NamedPoint<'a, Fr>],
+    local_point: &'a [Fr],
+    local_field_vectors: &'a [NamedFieldVector<Fr>],
+}
+
+fn evaluate_structured_polynomial_point(
+    plan: StructuredPolynomialPointPlan,
+    raw_point: &[Fr],
+    x_point: &[Fr],
+    y_point: &[Fr],
+) -> Result<Vec<Fr>, RuntimePlanError> {
+    if matches!(plan.segment, StructuredPolynomialPointSegment::Full)
+        && !matches!(plan.length, StructuredPolynomialPointLength::Full)
+    {
+        return Err(RuntimePlanError::InvalidProof {
+            driver: plan.source,
+            reason: "full output point segment requires full length",
+        });
+    }
+    let length = match plan.length {
+        StructuredPolynomialPointLength::Full => raw_point.len(),
+        StructuredPolynomialPointLength::XPoint => x_point.len(),
+        StructuredPolynomialPointLength::YPoint => y_point.len(),
+    };
+    let segment = match plan.segment {
+        StructuredPolynomialPointSegment::Full => raw_point,
+        StructuredPolynomialPointSegment::Prefix => raw_point
+            .get(..length)
+            .filter(|prefix| prefix.len() == length)
+            .ok_or(RuntimePlanError::InvalidInputLength {
+                input: plan.source,
+                expected: length,
+                actual: raw_point.len(),
+            })?,
+        StructuredPolynomialPointSegment::Suffix => raw_point
+            .get(raw_point.len().saturating_sub(length)..)
+            .filter(|suffix| suffix.len() == length)
+            .ok_or(RuntimePlanError::InvalidInputLength {
+                input: plan.source,
+                expected: length,
+                actual: raw_point.len(),
+            })?,
+    };
+    Ok(match plan.order {
+        StructuredPolynomialPointOrder::AsIs => segment.to_vec(),
+        StructuredPolynomialPointOrder::Reverse => reverse_slice(segment),
+    })
+}
+
+fn evaluate_structured_polynomial(
+    polynomial: StructuredPolynomialKind,
+    x: &[Fr],
+    y: Vec<Fr>,
+) -> Result<Fr, RuntimePlanError> {
+    Ok(match polynomial {
+        StructuredPolynomialKind::Eq => evaluate_eq_polynomial_mle(x, &y)?,
+        StructuredPolynomialKind::EqPlusOne => evaluate_eq_plus_one_polynomial_mle(x, y)?,
+        StructuredPolynomialKind::Lt => evaluate_lt_polynomial_mle(x, &y)?,
+    })
+}
+
+fn evaluate_eq_polynomial_mle(x: &[Fr], y: &[Fr]) -> Result<Fr, RuntimePlanError> {
+    EqPolynomial::<Fr>::try_mle(x, y).ok_or(RuntimePlanError::InvalidInputLength {
+        input: "sumcheck_output.eq",
+        expected: x.len(),
+        actual: y.len(),
+    })
+}
+
+fn evaluate_eq_plus_one_polynomial_mle(x: &[Fr], y: Vec<Fr>) -> Result<Fr, RuntimePlanError> {
+    let y_len = y.len();
+    EqPlusOnePolynomial::<Fr>::new(y)
+        .try_evaluate(x)
+        .ok_or(RuntimePlanError::InvalidInputLength {
+            input: "sumcheck_output.eq_plus_one",
+            expected: x.len(),
+            actual: y_len,
+        })
+}
+
+fn evaluate_lt_polynomial_mle(x: &[Fr], y: &[Fr]) -> Result<Fr, RuntimePlanError> {
+    LtPolynomial::try_evaluate(x, y).ok_or(RuntimePlanError::InvalidInputLength {
+        input: "sumcheck_output.lt",
+        expected: x.len(),
+        actual: y.len(),
+    })
+}
+
+#[derive(Default)]
+struct ScratchScalars {
+    values: BTreeMap<&'static str, Fr>,
+}
+
+impl ScratchScalars {
+    fn insert(&mut self, symbol: &'static str, value: Fr) {
+        let _ = self.values.insert(symbol, value);
+    }
+
+    fn scalar_or(&self, store: &ValueStore<Fr>, symbol: &'static str) -> Option<Fr> {
+        self.values
+            .get(symbol)
+            .copied()
+            .or_else(|| store.try_scalar(symbol))
+    }
+}
+
+fn evaluate_available_exprs_with_scratch(
+    field_exprs: &[FieldExprPlan],
+    scalar_exprs: &[ScalarExprPlan],
+    store: &ValueStore<Fr>,
+    scratch: &mut ScratchScalars,
+    context: RelationOutputContext<'_>,
+) -> Result<(), RuntimePlanError> {
+    loop {
+        let mut progress = 0usize;
+        for expr in field_exprs {
+            if scratch.scalar_or(store, expr.symbol).is_some() {
+                continue;
+            }
+            let Some(operands) = relation_output_expr_operands(expr, store, scratch) else {
+                continue;
+            };
+            scratch.insert(expr.symbol, evaluate_field_expr(expr, &operands)?);
+            progress += 1;
+        }
+        for expr in scalar_exprs {
+            if scratch.scalar_or(store, expr.symbol).is_some() {
+                continue;
+            }
+            let Some(value) = evaluate_relation_output_scalar_expr(expr, store, scratch, context)?
+            else {
+                continue;
+            };
+            scratch.insert(expr.symbol, value);
+            progress += 1;
+        }
+        if progress == 0 {
+            return Ok(());
+        }
+    }
+}
+
+fn relation_output_expr_operands(
+    expr: &FieldExprPlan,
+    store: &ValueStore<Fr>,
+    scratch: &ScratchScalars,
+) -> Option<Vec<Fr>> {
+    expr.operands
+        .iter()
+        .map(|operand| scratch.scalar_or(store, operand))
+        .collect()
+}
+
+fn evaluate_relation_output_scalar_expr(
+    expr: &ScalarExprPlan,
+    store: &ValueStore<Fr>,
+    scratch: &ScratchScalars,
+    context: RelationOutputContext<'_>,
+) -> Result<Option<Fr>, RuntimePlanError> {
+    match expr.kind {
+        ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => {
+            let [symbol] = expr.operands else {
+                return evaluate_scalar_expr(expr, &[]).map(Some);
+            };
+            let Some(values) = context
+                .local_field_vectors
+                .iter()
+                .find(|field_vector| field_vector.symbol == *symbol)
+                .map(|field_vector| field_vector.values.as_slice())
+                .or_else(|| store.try_field_vector(symbol))
+            else {
+                return Ok(None);
+            };
+            evaluate_scalar_expr(expr, values).map(Some)
+        }
+        ScalarExprKind::StructuredPolynomial {
+            polynomial,
+            x_point,
+            y_point,
+        } => evaluate_structured_polynomial_scalar(
+            expr.symbol,
+            expr.operands,
+            polynomial,
+            x_point,
+            y_point,
+            store,
+            context,
+        ),
+        ScalarExprKind::PowerStridedWeightedSum { .. } => expr
+            .operands
+            .iter()
+            .map(|operand| scratch.scalar_or(store, operand))
+            .collect::<Option<Vec<_>>>()
+            .map(|operands| evaluate_scalar_expr(expr, &operands).map(Some))
+            .transpose()
+            .map(Option::flatten),
+        ScalarExprKind::PointElement { index } => {
+            let [source] = expr.operands else {
+                return evaluate_scalar_expr(expr, &[]).map(Some);
+            };
+            let Some(point) = try_relation_output_x_point_source(
+                source,
+                context.instance_symbol,
+                context.local_points,
+                context.local_point,
+                store,
+            ) else {
+                return Ok(None);
+            };
+            let value = point
+                .get(index)
+                .copied()
+                .ok_or(RuntimePlanError::InvalidInputLength {
+                    input: expr.symbol,
+                    expected: index + 1,
+                    actual: point.len(),
+                })?;
+            Ok(Some(value))
+        }
+    }
+}
+
+fn evaluate_structured_polynomial_scalar(
+    symbol: &'static str,
+    operands: &[&'static str],
+    polynomial: StructuredPolynomialKind,
+    x_transform: StructuredPolynomialPointTransform,
+    y_transform: StructuredPolynomialPointTransform,
+    store: &ValueStore<Fr>,
+    context: RelationOutputContext<'_>,
+) -> Result<Option<Fr>, RuntimePlanError> {
+    require_operand_count(symbol, 2, operands.len())?;
+    let x_source = operands[0];
+    let y_source = operands[1];
+    let Some(x_raw_point) = try_relation_output_x_point_source(
+        x_source,
+        context.instance_symbol,
+        context.local_points,
+        context.local_point,
+        store,
+    ) else {
+        return Ok(None);
+    };
+    let Some(y_raw_point) = store.try_point(y_source) else {
+        return Ok(None);
+    };
+    let x_plan = StructuredPolynomialPointPlan {
+        source: x_source,
+        segment: x_transform.segment,
+        length: x_transform.length,
+        order: x_transform.order,
+    };
+    let y_plan = StructuredPolynomialPointPlan {
+        source: y_source,
+        segment: y_transform.segment,
+        length: y_transform.length,
+        order: y_transform.order,
+    };
+    let x_point =
+        evaluate_structured_polynomial_point(x_plan, x_raw_point, x_raw_point, y_raw_point)?;
+    let y_point =
+        evaluate_structured_polynomial_point(y_plan, y_raw_point, x_raw_point, y_raw_point)?;
+    evaluate_structured_polynomial(polynomial, &x_point, y_point).map(Some)
+}
+
+pub fn single_operand<F: Field>(
+    symbol: &'static str,
+    operands: &[F],
+) -> Result<F, RuntimePlanError> {
+    require_operand_count(symbol, 1, operands.len())?;
+    Ok(operands[0])
+}
+
+pub fn require_operand_count(
+    input: &'static str,
+    expected: usize,
+    actual: usize,
+) -> Result<(), RuntimePlanError> {
+    if expected == actual {
+        Ok(())
+    } else {
+        Err(RuntimePlanError::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        })
+    }
+}
+
+pub fn require_min_operand_count(
+    input: &'static str,
+    minimum: usize,
+    actual: usize,
+) -> Result<(), RuntimePlanError> {
+    if actual >= minimum {
+        Ok(())
+    } else {
+        Err(RuntimePlanError::InvalidInputLength {
+            input,
+            expected: minimum,
+            actual,
+        })
+    }
+}
+
+pub fn evaluate_field_expr<F: Field>(
+    expr: &FieldExprPlan,
+    operands: &[F],
+) -> Result<F, RuntimePlanError> {
+    match expr.kind {
+        FieldExprKind::OpeningEval => Ok(single_operand(expr.symbol, operands)?),
+        FieldExprKind::Add => {
+            require_operand_count(expr.symbol, 2, operands.len())?;
+            Ok(operands[0] + operands[1])
+        }
+        FieldExprKind::Sub => {
+            require_operand_count(expr.symbol, 2, operands.len())?;
+            Ok(operands[0] - operands[1])
+        }
+        FieldExprKind::Mul => {
+            require_operand_count(expr.symbol, 2, operands.len())?;
+            Ok(operands[0] * operands[1])
+        }
+        FieldExprKind::Sum => {
+            require_min_operand_count(expr.symbol, 1, operands.len())?;
+            Ok(operands
+                .iter()
+                .copied()
+                .fold(F::from_u64(0), |acc, operand| acc + operand))
+        }
+        FieldExprKind::Product => {
+            require_min_operand_count(expr.symbol, 1, operands.len())?;
+            Ok(operands
+                .iter()
+                .copied()
+                .fold(F::from_u64(1), |acc, operand| acc * operand))
+        }
+        FieldExprKind::Neg => {
+            require_operand_count(expr.symbol, 1, operands.len())?;
+            Ok(-operands[0])
+        }
+        FieldExprKind::Pow(exponent) => {
+            require_operand_count(expr.symbol, 1, operands.len())?;
+            Ok(pow_field(operands[0], exponent))
+        }
+        FieldExprKind::LagrangeBasisEval(domain_start, domain_size, index) => {
+            require_operand_count(expr.symbol, 1, operands.len())?;
+            let weights = lagrange_evals(domain_start, domain_size, operands[0]);
+            weights
+                .get(index)
+                .copied()
+                .ok_or(RuntimePlanError::InvalidInputLength {
+                    input: expr.symbol,
+                    expected: index + 1,
+                    actual: weights.len(),
+                })
+        }
+        FieldExprKind::LagrangeKernelEval(domain_start, domain_size) => {
+            require_operand_count(expr.symbol, 2, operands.len())?;
+            Ok(lagrange_kernel_eval(
+                domain_start,
+                domain_size,
+                operands[0],
+                operands[1],
+            ))
+        }
+    }
+}
+
+pub fn evaluate_scalar_expr<F: Field>(
+    expr: &ScalarExprPlan,
+    operands: &[F],
+) -> Result<F, RuntimePlanError> {
+    match expr.kind {
+        ScalarExprKind::FieldVectorSum => {
+            require_min_operand_count(expr.symbol, 1, operands.len())?;
+            Ok(operands
+                .iter()
+                .copied()
+                .fold(F::from_u64(0), |acc, operand| acc + operand))
+        }
+        ScalarExprKind::FieldVectorProduct => {
+            require_min_operand_count(expr.symbol, 1, operands.len())?;
+            Ok(operands
+                .iter()
+                .copied()
+                .fold(F::from_u64(1), |acc, operand| acc * operand))
+        }
+        ScalarExprKind::StructuredPolynomial { .. } => Err(RuntimePlanError::InvalidProof {
+            driver: expr.symbol,
+            reason:
+                "structured polynomial scalar expressions require relation-output point context",
+        }),
+        ScalarExprKind::PowerStridedWeightedSum {
+            row_count,
+            power_stride,
+            value_term_offsets,
+            shared_term_offsets,
+            row_term_offsets,
+        } => evaluate_power_strided_weighted_sum(
+            expr.symbol,
+            operands,
+            row_count,
+            power_stride,
+            value_term_offsets,
+            shared_term_offsets,
+            row_term_offsets,
+        ),
+        ScalarExprKind::PointElement { index: _ } => {
+            require_operand_count(expr.symbol, 1, operands.len())?;
+            Ok(operands[0])
+        }
+    }
+}
+
+fn evaluate_power_strided_weighted_sum<F: Field>(
+    symbol: &'static str,
+    operands: &[F],
+    row_count: usize,
+    power_stride: usize,
+    value_term_offsets: &[usize],
+    shared_term_offsets: &[usize],
+    row_term_offsets: &[usize],
+) -> Result<F, RuntimePlanError> {
+    let term_count = value_term_offsets.len() + shared_term_offsets.len() + row_term_offsets.len();
+    if row_count == 0 || term_count == 0 {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input: symbol,
+            expected: 1,
+            actual: 0,
+        });
+    }
+    let expected_operands =
+        1 + row_count + shared_term_offsets.len() + row_count * row_term_offsets.len();
+    require_operand_count(symbol, expected_operands, operands.len())?;
+
+    let gamma = operands[0];
+    let evals_start = 1;
+    let shared_start = evals_start + row_count;
+    let item_start = shared_start + shared_term_offsets.len();
+    let evals = &operands[evals_start..shared_start];
+    let shared_factors = &operands[shared_start..item_start];
+    let row_factors = &operands[item_start..];
+
+    let value_offset_powers = value_term_offsets
+        .iter()
+        .map(|&offset| pow_field(gamma, offset))
+        .collect::<Vec<_>>();
+    let shared_terms = shared_term_offsets
+        .iter()
+        .zip(shared_factors.iter())
+        .map(|(&offset, &factor)| (pow_field(gamma, offset), factor))
+        .collect::<Vec<_>>();
+    let row_offset_powers = row_term_offsets
+        .iter()
+        .map(|&offset| pow_field(gamma, offset))
+        .collect::<Vec<_>>();
+
+    let gamma_stride = pow_field(gamma, power_stride);
+    let mut gamma_base = F::from_u64(1);
+    let mut result = F::from_u64(0);
+    for (eval_index, &eval) in evals.iter().enumerate() {
+        let weighted_eval = eval * gamma_base;
+        for offset_power in &value_offset_powers {
+            result += weighted_eval * *offset_power;
+        }
+        for (offset_power, factor) in &shared_terms {
+            result += weighted_eval * *factor * *offset_power;
+        }
+        for (term_index, offset_power) in row_offset_powers.iter().enumerate() {
+            let factor = row_factors[term_index * row_count + eval_index];
+            result += weighted_eval * factor * *offset_power;
+        }
+        gamma_base *= gamma_stride;
+    }
+    Ok(result)
+}
+
+pub fn field_powers(base: Fr, count: usize) -> Vec<Fr> {
+    let mut powers = Vec::with_capacity(count);
+    let mut power = Fr::from_u64(1);
+    for _ in 0..count {
+        powers.push(power);
+        power *= base;
+    }
+    powers
+}
+
+pub fn prefix_point<'a, F: Field>(
+    point: &'a [F],
+    length: usize,
+    input: &'static str,
+) -> Result<&'a [F], RuntimePlanError> {
+    point
+        .get(..length)
+        .filter(|prefix| prefix.len() == length)
+        .ok_or(RuntimePlanError::InvalidInputLength {
+            input,
+            expected: length,
+            actual: point.len(),
+        })
+}
+
+pub fn suffix_point<'a, F: Field>(
+    point: &'a [F],
+    length: usize,
+    input: &'static str,
+) -> Result<&'a [F], RuntimePlanError> {
+    point
+        .get(point.len().saturating_sub(length)..)
+        .filter(|suffix| suffix.len() == length)
+        .ok_or(RuntimePlanError::InvalidInputLength {
+            input,
+            expected: length,
+            actual: point.len(),
+        })
+}
+
+pub fn store_scalar(store: &ValueStore<Fr>, symbol: &'static str) -> Result<Fr, RuntimePlanError> {
+    store.scalar_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol })
+}
+
+pub fn store_point<'a>(
+    store: &'a ValueStore<Fr>,
+    symbol: &'static str,
+) -> Result<&'a [Fr], RuntimePlanError> {
+    store.point_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol })
+}
+
+pub fn append_labeled_scalar<T>(transcript: &mut T, label: &'static str, scalar: &Fr)
+where
+    T: Transcript<Challenge = Fr>,
+{
+    transcript.append(&Label(label.as_bytes()));
+    transcript.append(scalar);
+}
+
+pub fn append_opening_claims<T, E>(
+    opening_inputs: &[OpeningInputPlan],
+    opening_claims: &[OpeningClaimPlan],
+    opening_batches: &[OpeningBatchPlan],
+    store: &mut ValueStore<Fr>,
+    transcript: &mut T,
+    evals: &[StageNamedEval<Fr>],
+    missing_claim: impl Fn(&'static str, &'static str) -> E,
+    missing_value: impl Fn(&'static str) -> E,
+) -> Result<(), E>
+where
+    T: Transcript<Challenge = Fr>,
+{
+    if opening_batches.is_empty() {
+        for eval in evals {
+            append_labeled_scalar(transcript, "opening_claim", &eval.value);
+        }
+        return Ok(());
+    }
+    let mut seen = opening_inputs
+        .iter()
+        .filter_map(|input| {
+            store
+                .try_point(input.symbol)
+                .map(|point| (input.claim_kind, input.oracle, point.to_vec()))
+        })
+        .collect::<Vec<_>>();
+    for batch in opening_batches {
+        for &symbol in batch.claim_operands {
+            let claim = opening_claims
+                .iter()
+                .find(|claim| claim.symbol == symbol)
+                .ok_or_else(|| missing_claim(batch.symbol, symbol))?;
+            let point = store.point_or(claim.point_source, &missing_value)?.to_vec();
+            if seen.iter().any(|(kind, oracle, seen_point)| {
+                *kind == claim.claim_kind && *oracle == claim.oracle && seen_point == &point
+            }) {
+                continue;
+            }
+            let value = store.scalar_or(claim.eval_source, &missing_value)?;
+            append_labeled_scalar(transcript, "opening_claim", &value);
+            seen.push((claim.claim_kind, claim.oracle, point));
+        }
+    }
+    Ok(())
+}
+
+pub fn pow_field<F: Field>(base: F, mut exponent: usize) -> F {
+    let mut result = F::one();
+    let mut power = base;
+    while exponent != 0 {
+        if exponent & 1 == 1 {
+            result *= power;
+        }
+        power = power.square();
+        exponent >>= 1;
+    }
+    result
+}
+
+pub fn reverse_slice(values: &[Fr]) -> Vec<Fr> {
+    values.iter().rev().copied().collect()
+}
+
+#[cfg(test)]
+#[expect(
+    clippy::unwrap_used,
+    reason = "tests assert the success and error paths directly"
+)]
+mod tests {
+    use super::{
+        evaluate_relation_output_for_instance, evaluate_scalar_expr, FieldExprKind, FieldExprPlan,
+        Fr, NamedEvalFamilyPlan, RelationOutputPlan, RuntimePlanError, ScalarExprKind,
+        ScalarExprPlan, StageNamedEval, StageSumcheckOutput, StructuredPolynomialKind,
+        StructuredPolynomialPointLength, StructuredPolynomialPointOrder,
+        StructuredPolynomialPointSegment, StructuredPolynomialPointTransform, SumcheckEvalPlan,
+        SumcheckInstanceResultPlan, SumcheckPointOrder, SumcheckProof, ValueStore,
+    };
+
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    enum TestRelation {
+        Output,
+        Sibling,
+    }
+
+    #[test]
+    fn value_store_evaluates_named_eval_families_as_field_vectors() {
+        let mut store = ValueStore::default();
+        store.insert_scalar("eval.a", Fr::from_u64(2));
+        store.insert_scalar("eval.b", Fr::from_u64(3));
+
+        store
+            .evaluate_named_eval_families(&[NamedEvalFamilyPlan {
+                symbol: "family.ab",
+                evals: &["eval.a", "eval.b"],
+            }])
+            .unwrap();
+
+        assert_eq!(
+            store.try_field_vector("family.ab"),
+            Some([Fr::from_u64(2), Fr::from_u64(3)].as_slice())
+        );
+    }
+
+    #[test]
+    fn value_store_rejects_named_eval_family_missing_eval() {
+        let mut store = ValueStore::<Fr>::default();
+        let error = store
+            .evaluate_named_eval_families(&[NamedEvalFamilyPlan {
+                symbol: "family.ab",
+                evals: &["eval.missing"],
+            }])
+            .unwrap_err();
+
+        assert_eq!(
+            error,
+            RuntimePlanError::MissingValue {
+                symbol: "eval.missing"
+            }
+        );
+    }
+
+    #[test]
+    fn value_store_requires_sumcheck_eval_names_to_match() {
+        let mut store = ValueStore::default();
+        let instance_results: &[SumcheckInstanceResultPlan<TestRelation>] = &[];
+        let error = store
+            .observe_sumcheck_output(
+                instance_results,
+                &[SumcheckEvalPlan {
+                    symbol: "planned.eval",
+                    source: "driver",
+                    name: "planned.eval.name",
+                    index: 0,
+                    oracle: "Oracle",
+                }],
+                &StageSumcheckOutput {
+                    driver: "driver",
+                    point: Vec::new(),
+                    evals: vec![StageNamedEval {
+                        name: "wrong.eval.name",
+                        oracle: "Oracle",
+                        value: Fr::from_u64(7),
+                    }],
+                    proof: SumcheckProof::default(),
+                },
+                |_, point| Ok(point),
+                |input, expected, actual| RuntimePlanError::InvalidInputLength {
+                    input,
+                    expected,
+                    actual,
+                },
+                |symbol| RuntimePlanError::MissingValue { symbol },
+            )
+            .unwrap_err();
+
+        assert_eq!(
+            error,
+            RuntimePlanError::MissingValue {
+                symbol: "planned.eval"
+            }
+        );
+        assert_eq!(store.try_scalar("planned.eval"), None);
+    }
+
+    #[test]
+    fn value_store_evaluates_field_vector_exprs() {
+        let mut store = ValueStore::default();
+        store.insert_field_vector("family.ab", vec![Fr::from_u64(2), Fr::from_u64(3)]);
+
+        store
+            .evaluate_available_exprs(
+                &[],
+                &[
+                    ScalarExprPlan {
+                        symbol: "family.ab.product",
+                        kind: ScalarExprKind::FieldVectorProduct,
+                        operands: &["family.ab"],
+                    },
+                    ScalarExprPlan {
+                        symbol: "family.ab.sum",
+                        kind: ScalarExprKind::FieldVectorSum,
+                        operands: &["family.ab"],
+                    },
+                ],
+            )
+            .unwrap();
+
+        assert_eq!(store.try_scalar("family.ab.product"), Some(Fr::from_u64(6)));
+        assert_eq!(store.try_scalar("family.ab.sum"), Some(Fr::from_u64(5)));
+    }
+
+    #[test]
+    fn value_store_evaluates_point_element_and_lagrange_kernel_exprs() {
+        let mut store = ValueStore::default();
+        store.insert_point("point.r", vec![Fr::from_u64(2)]);
+        store.insert_scalar("tau", Fr::from_u64(5));
+
+        store
+            .evaluate_available_exprs(
+                &[FieldExprPlan {
+                    symbol: "kernel",
+                    kind: FieldExprKind::LagrangeKernelEval(-1, 3),
+                    operands: &["tau", "r0"],
+                }],
+                &[ScalarExprPlan {
+                    symbol: "r0",
+                    kind: ScalarExprKind::PointElement { index: 0 },
+                    operands: &["point.r"],
+                }],
+            )
+            .unwrap();
+
+        assert_eq!(store.try_scalar("r0"), Some(Fr::from_u64(2)));
+        assert_eq!(
+            store.try_scalar("kernel"),
+            Some(jolt_poly::lagrange::lagrange_kernel_eval(
+                -1,
+                3,
+                Fr::from_u64(5),
+                Fr::from_u64(2),
+            ))
+        );
+    }
+
+    #[test]
+    fn scalar_expr_evaluates_power_strided_weighted_sum() {
+        let value = evaluate_scalar_expr(
+            &ScalarExprPlan {
+                symbol: "family.weighted",
+                kind: ScalarExprKind::PowerStridedWeightedSum {
+                    row_count: 2,
+                    power_stride: 3,
+                    value_term_offsets: &[0],
+                    shared_term_offsets: &[1],
+                    row_term_offsets: &[2],
+                },
+                operands: &["gamma", "eval.a", "eval.b", "shared.eq", "item.a", "item.b"],
+            },
+            &[
+                Fr::from_u64(2),
+                Fr::from_u64(3),
+                Fr::from_u64(5),
+                Fr::from_u64(7),
+                Fr::from_u64(11),
+                Fr::from_u64(13),
+            ],
+        )
+        .unwrap();
+
+        assert_eq!(value, Fr::from_u64(2857));
+    }
+
+    #[test]
+    fn relation_output_evaluates_structured_polynomial_scalar_exprs() {
+        let x = [Fr::from_u64(1), Fr::from_u64(0)];
+        let mut store = ValueStore::default();
+        store.insert_point("point.y", x.to_vec());
+
+        let value = evaluate_relation_output_for_instance(
+            &[RelationOutputPlan {
+                relation: TestRelation::Output,
+                local_scalars: &[],
+                expected_output: "eq.xy",
+            }],
+            &[],
+            &[ScalarExprPlan {
+                symbol: "eq.xy",
+                kind: ScalarExprKind::StructuredPolynomial {
+                    polynomial: StructuredPolynomialKind::Eq,
+                    x_point: StructuredPolynomialPointTransform {
+                        segment: StructuredPolynomialPointSegment::Full,
+                        length: StructuredPolynomialPointLength::Full,
+                        order: StructuredPolynomialPointOrder::AsIs,
+                    },
+                    y_point: StructuredPolynomialPointTransform {
+                        segment: StructuredPolynomialPointSegment::Full,
+                        length: StructuredPolynomialPointLength::Full,
+                        order: StructuredPolynomialPointOrder::AsIs,
+                    },
+                },
+                operands: &["instance", "point.y"],
+            }],
+            &[],
+            &store,
+            &SumcheckInstanceResultPlan {
+                symbol: "instance",
+                source: "driver",
+                claim: "claim",
+                relation: TestRelation::Output,
+                index: 0,
+                point_arity: 2,
+                num_rounds: 2,
+                round_offset: 0,
+                point_order: SumcheckPointOrder::AsIs,
+                degree: 2,
+            },
+            &[],
+            &[],
+            &[],
+            &x,
+        )
+        .unwrap();
+
+        assert_eq!(value, Fr::from_u64(1));
+    }
+
+    #[test]
+    fn relation_output_skips_unavailable_sibling_instance_exprs() {
+        let x = [Fr::from_u64(1), Fr::from_u64(0)];
+        let mut store = ValueStore::default();
+        store.insert_point("point.y", x.to_vec());
+
+        let structured_eq = ScalarExprKind::StructuredPolynomial {
+            polynomial: StructuredPolynomialKind::Eq,
+            x_point: StructuredPolynomialPointTransform {
+                segment: StructuredPolynomialPointSegment::Full,
+                length: StructuredPolynomialPointLength::Full,
+                order: StructuredPolynomialPointOrder::AsIs,
+            },
+            y_point: StructuredPolynomialPointTransform {
+                segment: StructuredPolynomialPointSegment::Full,
+                length: StructuredPolynomialPointLength::Full,
+                order: StructuredPolynomialPointOrder::AsIs,
+            },
+        };
+        let value = evaluate_relation_output_for_instance(
+            &[
+                RelationOutputPlan {
+                    relation: TestRelation::Output,
+                    local_scalars: &[],
+                    expected_output: "eq.current",
+                },
+                RelationOutputPlan {
+                    relation: TestRelation::Sibling,
+                    local_scalars: &[],
+                    expected_output: "eq.sibling",
+                },
+            ],
+            &[],
+            &[
+                ScalarExprPlan {
+                    symbol: "eq.sibling",
+                    kind: structured_eq,
+                    operands: &["sibling.instance", "point.y"],
+                },
+                ScalarExprPlan {
+                    symbol: "eq.current",
+                    kind: structured_eq,
+                    operands: &["instance", "point.y"],
+                },
+            ],
+            &[],
+            &store,
+            &SumcheckInstanceResultPlan {
+                symbol: "instance",
+                source: "driver",
+                claim: "claim",
+                relation: TestRelation::Output,
+                index: 0,
+                point_arity: 2,
+                num_rounds: 2,
+                round_offset: 0,
+                point_order: SumcheckPointOrder::AsIs,
+                degree: 2,
+            },
+            &[],
+            &[],
+            &[],
+            &x,
+        )
+        .unwrap();
+
+        assert_eq!(value, Fr::from_u64(1));
+    }
+
+    #[test]
+    fn relation_output_evaluates_eval_family_vectors_from_proof_evals() {
+        let value = evaluate_relation_output_for_instance(
+            &[RelationOutputPlan {
+                relation: TestRelation::Output,
+                local_scalars: &[],
+                expected_output: "family.product",
+            }],
+            &[],
+            &[ScalarExprPlan {
+                symbol: "family.product",
+                kind: ScalarExprKind::FieldVectorProduct,
+                operands: &["family.ab"],
+            }],
+            &[NamedEvalFamilyPlan {
+                symbol: "family.ab",
+                evals: &["eval.a", "eval.b"],
+            }],
+            &ValueStore::default(),
+            &SumcheckInstanceResultPlan {
+                symbol: "instance",
+                source: "driver",
+                claim: "claim",
+                relation: TestRelation::Output,
+                index: 0,
+                point_arity: 0,
+                num_rounds: 0,
+                round_offset: 0,
+                point_order: SumcheckPointOrder::AsIs,
+                degree: 2,
+            },
+            &[
+                StageNamedEval {
+                    name: "eval.a",
+                    oracle: "A",
+                    value: Fr::from_u64(2),
+                },
+                StageNamedEval {
+                    name: "eval.b",
+                    oracle: "B",
+                    value: Fr::from_u64(3),
+                },
+            ],
+            &[],
+            &[],
+            &[],
+        )
+        .unwrap();
+
+        assert_eq!(value, Fr::from_u64(6));
+    }
+
+    #[test]
+    fn relation_output_rejects_structured_polynomial_dimension_mismatch() {
+        let x = [Fr::from_u64(1)];
+        let y = [Fr::from_u64(1), Fr::from_u64(0)];
+        let mut store = ValueStore::default();
+        store.insert_point("point.y", y.to_vec());
+
+        let error = evaluate_relation_output_for_instance(
+            &[RelationOutputPlan {
+                relation: TestRelation::Output,
+                local_scalars: &[],
+                expected_output: "eq.xy",
+            }],
+            &[],
+            &[ScalarExprPlan {
+                symbol: "eq.xy",
+                kind: ScalarExprKind::StructuredPolynomial {
+                    polynomial: StructuredPolynomialKind::Eq,
+                    x_point: StructuredPolynomialPointTransform {
+                        segment: StructuredPolynomialPointSegment::Full,
+                        length: StructuredPolynomialPointLength::Full,
+                        order: StructuredPolynomialPointOrder::AsIs,
+                    },
+                    y_point: StructuredPolynomialPointTransform {
+                        segment: StructuredPolynomialPointSegment::Full,
+                        length: StructuredPolynomialPointLength::Full,
+                        order: StructuredPolynomialPointOrder::AsIs,
+                    },
+                },
+                operands: &["instance", "point.y"],
+            }],
+            &[],
+            &store,
+            &SumcheckInstanceResultPlan {
+                symbol: "instance",
+                source: "driver",
+                claim: "claim",
+                relation: TestRelation::Output,
+                index: 0,
+                point_arity: 1,
+                num_rounds: 1,
+                round_offset: 0,
+                point_order: SumcheckPointOrder::AsIs,
+                degree: 2,
+            },
+            &[],
+            &[],
+            &[],
+            &x,
+        )
+        .unwrap_err();
+
+        assert_eq!(
+            error,
+            RuntimePlanError::InvalidInputLength {
+                input: "sumcheck_output.eq",
+                expected: 1,
+                actual: 2
+            }
+        );
+    }
+}
diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md
index 4f0aa601ff..f45bfb76c0 100644
--- a/crates/bolt/GOAL.md
+++ b/crates/bolt/GOAL.md
@@ -9,11 +9,13 @@ preserving the existing full-`Fr` Jolt semantics.
 ## Objective
 
 Refactor the Bolt-generated Jolt verifier pipeline so the generated verifier is
-a small orchestration layer plus declarative verifier plans, backed by reusable
-verifier runtime modules. The compiler should continue to own protocol facts
-through MLIR and typed plan data; generated Rust should not rediscover Jolt
-semantics late through ad hoc string matching or repeated stage-local helper
-code.
+a typed verifier program: a small orchestration layer plus declarative plans for
+commitments, transcript events, sumcheck drivers, value-graph computations,
+opening batches, and PCS checks, backed by reusable verifier runtime modules.
+The compiler should continue to own protocol facts through MLIR and typed plan
+data; generated Rust should not rediscover Jolt semantics late through ad hoc
+string matching, repeated stage-local helper code, or hardcoded assumptions that
+the verifier must always have a fixed number of numbered stages.
 
 Starting baseline:
 
@@ -23,16 +25,20 @@ stage6 + stage7:        ~13.2k LOC
 verifier.rs:              649 LOC
 ```
 
-Current locked cleanup baseline:
+Current cleanup baseline (S2.75-S5 verifier-program cutover):
 
 ```text
-generated jolt-verifier total:     7,755 LOC
-generated verifier surface:        5,966 LOC
-shared verifier runtime:           1,789 LOC
-stage6 + stage7:                   1,669 LOC
-verifier.rs:                         487 LOC
+generated jolt-verifier total:     6,752 LOC
+generated verifier surface:        6,056 LOC
+tier A (Bolt verifier runtime):    2,520 LOC   crates/bolt-verifier-runtime/src/lib.rs
+tier B (Jolt verifier core):         696 LOC   stages/jolt_relations.rs
+stage6 + stage7:                   1,547 LOC
+verifier.rs:                         696 LOC
 ```
 
+The shared runtime is now split along an explicit audit boundary. See
+"Audit Tiers" below.
+
 Target:
 
 ```text
@@ -40,18 +46,111 @@ generated verifier surface:        <= 4k-6k LOC
 stretch generated surface:         <= 2k-3k LOC
 verifier.rs orchestration:         <= 350-500 LOC
 stage6 + stage7 generated surface: <= 2k-3k LOC
-shared runtime/helpers:            allowed when generic, named, and reviewed
+tier A (Bolt verifier runtime):    shrink toward <= 800 LOC as more helpers
+                                   become typed plan data driven from MLIR
+tier B (Jolt verifier core):       stable around current size; growth here is
+                                   a protocol-math decision, not emitter creep
 ```
 
 The goal is to reduce the human-facing generated verifier surface by roughly an
 order of magnitude. Shared runtime code may exist, but it must be modular,
 boring to audit, and driven by explicit MLIR-derived plan data.
 
+Current S2.75-S5 implementation status:
+
+- S3/S4/S5 have largely landed in the generated verifier shape: Stage 2-7 emit
+  typed scalar/point/vector/eval-family refs and `RelationOutputPlan` rows with
+  closed relation IDs, old eval-prefix reconstruction sites are gated at zero,
+  and handwritten
+  `expected_stage67_*` output helpers are gone from generated/runtime code.
+- S2.75 is now largely implemented at the CPU-to-Rust planning boundary:
+  `VerifierStagePlan` is built through named planning functions for program
+  steps, transcript flow, sumchecks, value/relation outputs, opening flow, and
+  relation-local inputs. Stage 2-7 verifier sumcheck-flow, relation-output, and
+  opening-flow validation are owned by `VerifierStagePlan`; Stage 2 also uses
+  the shared CPU row types instead of local copies. Remaining S2.75 risk is no
+  longer the existence of the planning boundary, but the audit quality of the
+  handwritten Stage 2 relation-output formulas and any target validation still
+  tied to emitter-side checks.
+- Performance evidence remains a live completion gate. The SHA2-chain perf
+  oracles must be rerun for the interpreter-heavy slices before this goal is
+  closed.
+
+## Audit Tiers
+
+The verifier code is partitioned into three explicit audit tiers. The `Concrete
+Gates` section enforces a per-tier LOC ceiling for each tier independently so
+growth is attributed to the right trust boundary.
+
+- **Tier A (Bolt verifier runtime):** generic, protocol-agnostic helpers
+  (plan structs, `ValueStore`, sumcheck driver loop, opening-equality
+  interpreter, transcript helpers). Lives in
+  `crates/bolt-verifier-runtime/src/lib.rs` as a standalone workspace crate.
+  Tier A should ratchet *down* over time as more helpers move into typed plan
+  data driven from MLIR. It must stay protocol-neutral; Jolt-specific math and
+  point normalization belong in Tier B or typed Jolt plan data.
+
+- **Tier B (audited Jolt verifier core):** hand-written Jolt-specific verifier
+  math and relations (Stage 6/7 evaluators, `normalize_*_point`,
+  `bytecode_gamma_powers`, the `Stage67Bytecode*` glue, polynomial-evaluation
+  primitives). Lives in `crates/jolt-verifier/src/stages/jolt_relations.rs`,
+  generated from
+  `crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template`. Tier
+  B is the audit surface for Jolt-specific math; it is expected to stay
+  roughly its current size and any growth here must be reviewed as a
+  *protocol-math* decision, not emitter LOC.
+
+- **Tier C (generated declarative stage data + orchestration):** typed plans,
+  thin `verify_stageN` wrappers, and `verifier.rs`. This is everything else
+  under `crates/jolt-verifier/src/`. Tier C should be aggressively shrunk
+  toward the stretch target.
+
+This split was introduced by the S1 audit-tier refactor. The pre-split
+"shared verifier runtime" framing (a single ~1.8k-LOC `common.rs` mixing
+generic Bolt scaffolding and Jolt-specific math) is retired.
+
+The implementation plan for slices S2 — S6 (which progressively replace
+stage-shaped Rust with a typed verifier-program model by lifting hand-written
+Rust into MLIR vocabulary) lives in
+`crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md`.
+
+## Design Philosophy
+
+The end state is a typed verifier IR, not a cleverer Rust template system.
+Generated verifier Rust should be mostly const plan data plus thin calls into
+reviewed interpreters. The Rust emitter should project MLIR-derived facts; it
+should not infer verifier semantics from string names, stage-local naming
+conventions, or generated helper bodies.
+
+Typed symbol handles should carry verifier references wherever possible. Plain
+strings may remain as diagnostics and serialization names, but they should not
+be the execution contract for claim, eval, point, relation, or opening lookup.
+
+Verifier values should live in explicit domains:
+
+```text
+scalar field values
+multilinear query points
+ordered field vectors / eval families
+opening claims and batches
+relation expected-output values
+protocol-specific encoding tables
+```
+
+When a cleanup slice moves logic out of generated Rust, the semantics must stay
+visible in MLIR, typed attrs, or typed plan rows. Moving semantics into opaque
+runtime code without a readable generated plan is not progress.
+
 This verifier cleanup is coupled to the generic protocol cleanup in
 `GENERIC_PROTOCOL_GOAL.md`: shrinking the generated verifier should move generic
 mechanics into Bolt IR/typed plans and shared runtime, not into Jolt-specific
 emitter special cases.
 
+Numbered stages may remain as proof-layout slots and diagnostic scopes, but
+they are not the final architecture. The final architecture is an explicit
+verifier program whose steps describe commitment receipt, transcript events,
+sumcheck verification, value evaluation, opening batching, and PCS verification.
+
 ## Locked Genericity Decisions
 
 The next cleanup track should make Jolt a quarantined protocol package over
@@ -75,50 +174,174 @@ generic Bolt compiler infrastructure:
   still genuinely protocol-specific and which are ready to lift into generic
   typed-plan emission.
 
-## Immediate Goal-Mode Slice
+## Current State
 
-First objective for another agent:
+The initial quarantine slice is complete:
 
 ```text
-Quarantine Jolt-specific artifact APIs out of generic Rust artifact assembly
-while preserving generated output and all current gates.
+generic artifact assembly no longer owns Jolt artifact APIs
+root bolt exports keep Jolt helpers under bolt::protocols::jolt
+generic compiler source is guarded against accidental Jolt protocol strings
+checked-in generated verifier is under the current LOC target
+shared verifier plan/runtime scaffolding lives in crates/bolt-verifier-runtime
 ```
 
-Required steps:
-
-1. Move `JoltProtocolStage`, `jolt_artifact_config`, `jolt_rust_artifact`,
-   `assemble_jolt_*`, `write_jolt_generated_crates`, and
-   `validate_jolt_rust_artifact_imports` out of generic
-   `crates/bolt/src/emit/rust/artifacts.rs` into a Jolt-owned module such as
-   `crates/bolt/src/protocols/jolt/artifacts.rs`.
-2. Keep `ProtocolArtifactConfig`, `ProtocolStage`, `ProtocolRustArtifact`,
-   `GeneratedCrate`, `assemble_generated_crates`, `write_generated_crates`, and
-   `validate_rust_artifact_imports` in the generic artifact layer.
-3. Stop re-exporting Jolt APIs from `crates/bolt/src/lib.rs`; update callers in
-   Bolt tests, `jolt-equivalence`, and perf harnesses to import from
-   `bolt::protocols::jolt`.
-4. Add the first genericity hygiene test that rejects new Jolt protocol strings
-   in generic compiler modules, using a small documented allowlist only for
-   migration leftovers.
-5. Run focused generation/import gates and confirm checked-in generated role
-   crates are unchanged unless an intentional artifact-structure change is
-   documented.
-
-Acceptance criteria:
+The remaining work is no longer a stage bring-up task or a pure LOC cleanup.
+This goal is now owned as a verifier-quality cutover: make the generated
+verifier a Rust artifact that a reviewer can audit directly, without needing to
+understand Bolt lowering internals.
 
-```text
-generic artifact assembly has no Jolt stage enum or Jolt artifact config
-root bolt exports are generic-only
-Jolt artifact helpers are namespaced under protocols::jolt
-generated jolt-prover/jolt-verifier are byte-for-byte unchanged, or changes are intentional
-genericity hygiene gate exists
-existing generated-artifact and verifier-boundary gates pass
-```
+## Completion Plan
+
+Work proceeds in reviewable slices. Each slice must reduce a concrete readability
+or soundness risk, regenerate checked-in artifacts, and preserve the semantic
+oracles.
+
+1. **Typed plan vocabulary**
+
+   Replace execution-relevant strings with typed Rust plan data:
+
+   ```text
+   StageId
+   ProofSlot
+   ProgramStepKind
+   TranscriptEventKind
+   RelationKind
+   FieldExprKind
+   OracleId
+   DomainId
+   ClaimKind
+   PointSource
+   EvalSource
+   OpeningEqualityMode
+   ```
+
+   Diagnostic names may remain as `symbol` fields, but verifier execution must
+   not branch on loose strings when a closed enum or structured ID can express
+   the same fact.
+
+2. **Generic stage runtime**
+
+   Collapse stage-local verifier loops into one reviewed runtime path:
+
+   ```text
+   verify transcript events
+   evaluate field expression plans
+   verify sumcheck drivers
+   collect named evals and output claims
+   construct opening claims
+   check opening equalities
+   convert proof records into runtime inputs
+   ```
+
+   Stage files should keep only stage-specific plan constants, typed relation
+   adapters when truly required, and thin `verify_stageN` wrappers.
+
+3. **Readable generated plan layout**
+
+   Reformat emitted Rust so a human can scan it by protocol concept:
+
+   ```text
+   params
+   transcript events
+   opening inputs
+   field expressions
+   sumcheck drivers
+   evals
+   opening claims
+   opening batches
+   stage program
+   ```
+
+   Avoid generated one-line functions, `#[rustfmt::skip]` blocks for ordinary
+   data, pipe-delimited operand strings, and stage-local macro tricks unless
+   they make the artifact materially easier to read.
+
+4. **Compact expression encoding**
+
+   Replace verbose string formulas and operand encodings with typed compact
+   expression rows:
+
+   ```text
+   FieldExprKind::Add { lhs, rhs }
+   FieldExprKind::Mul { lhs, rhs }
+   FieldExprKind::Pow { base, exponent }
+   FieldExprKind::LagrangeBasisEval { domain, index, point }
+   ```
+
+   Repeated operands and symbols should be pooled or indexed when doing so makes
+   the generated Rust clearer, not merely shorter.
+
+5. **Typed relation dispatch**
+
+   Replace relation-name matching with typed `RelationKind` dispatch and
+   relation-specific plan payloads. Any remaining string dispatch must be
+   explicitly allowlisted, documented as temporary, and protected by tests that
+   fail when the allowlist grows.
+
+6. **Stage 8 boundary cleanup**
+
+   Keep Dory/evaluation verification reviewed and explicit, but give Stage 8 a
+   typed input contract from earlier stages:
+
+   ```text
+   committed opening IDs
+   virtual opening IDs
+   ordered opening batches
+   evaluation point sources
+   PCS proof slots
+   transcript labels
+   ```
+
+   Stage 8 does not have to become fully generic before this goal completes, but
+   it must not rely on name-then-position fallback or hidden generated ordering.
+
+7. **Hardening suite**
+
+   Add or preserve negative oracles while the Rust shape changes. The generated
+   verifier must reject malformed plans/proofs with typed errors, not panic or
+   silently default missing values.
+
+8. **Independent readability review**
+
+   Treat readability as a first-class gate. Before declaring this goal complete,
+   run a blind review where reviewers see only:
+
+   ```text
+   current handwritten/verifier-style Rust surface
+   generated jolt-verifier Rust surface
+   brief protocol-stage context
+   no Bolt lowering or emitter implementation details
+   ```
+
+   A small council of reviewers, human or model, should be able to answer:
+
+   ```text
+   What does each stage verify?
+   Where are transcript challenges absorbed or squeezed?
+   Which openings are checked, and at what points?
+   Where does sumcheck verification happen?
+   What code is trusted runtime logic versus declarative generated data?
+   How would a malformed proof be rejected?
+   ```
+
+   The generated verifier passes this gate only if the answers are findable from
+   the emitted Rust with minimal compiler context.
 
 ## Non-Negotiables
 
 - Preserve the current full-field non-zk Jolt protocol path:
   `Transcript<Challenge = Fr>`.
+- Preserve or improve readability. A slice that reduces LOC by hiding verifier
+  semantics in opaque runtime code, compiler-only conventions, or dense tables
+  that blind reviewers cannot audit fails this goal.
+- Do not regress final LOC. Temporary slice-local growth is acceptable only when
+  it moves hand-written protocol math into declarative typed plan data and the
+  completed stack remains no larger than the locked post-S1 baselines above.
+- Do not silently regress performance. Existing SHA2-chain core-vs-Bolt perf
+  oracles are required smoke gates; interpreter-heavy slices must also record a
+  before/after verifier-time baseline and fix or explicitly justify any
+  repeatable regression.
 - `jolt-verifier` must not depend on `jolt-prover`, `jolt-kernels`,
   `jolt-core`, `jolt-equivalence`, `jolt-profiling`, or tracer internals.
 - Bolt compiler boundaries remain:
@@ -129,6 +352,9 @@ existing generated-artifact and verifier-boundary gates pass
   validators, lowering passes, or typed verifier plans. The Rust emitter should
   not infer protocol meaning from loose strings when a typed enum, attr, op, or
   plan field can carry it.
+- Do not keep old stage-local execution paths as verifier fallbacks once typed
+  verifier-program execution lands. Rollback is a git operation, not an
+  alternate runtime path.
 - Generated verifier files should be mostly declarative:
 
 ```rust
@@ -149,7 +375,8 @@ crates/jolt-verifier
   src/verifier.rs
     public API
     proof shape
-    stage ordering
+    verifier-program execution
+    proof-slot/checkpoint layout
     error mapping
 
   src/stages/
@@ -187,6 +414,11 @@ How are opening/eval consistency checks performed?
 How are proof records converted into runtime verifier inputs?
 ```
 
+The checked-in generated Rust should expose a top-level `VERIFIER_PROGRAM` (or
+equivalent) that a reviewer can scan to see the whole verifier flow. A reviewer
+should not need to know how many stage files the emitter happened to produce in
+order to understand verifier control flow.
+
 ## Main Refactor Tracks
 
 1. **Verifier runtime extraction**
@@ -293,19 +525,33 @@ generated verifier imports no forbidden crates
 
 ## Concrete Gates
 
-Readability and LOC gates:
+Readability and LOC gates (enforced by `crates/bolt/tests/verifier_cleanup.rs`):
 
 ```text
 total generated jolt-verifier LOC trends down
-verifier.rs <= 500 LOC, stretch <= 350
+generated verifier surface (Tier C) <= 6.5k, target <= 6k, stretch <= 3k
+generated Tier A surface in jolt-verifier stays at zero; standalone
+bolt-verifier-runtime ratchets down separately
+tier B audited Jolt verifier core <= 700 (growth requires protocol-math review)
+verifier.rs <= 850 LOC today, target <= 500 LOC, stretch <= 350
 stage6 + stage7 generated LOC <= 3k-5k, stretch <= 2k-3k
 no duplicate stage-local generic plan structs
 no duplicate stage-local field-expression interpreter
 no duplicate stage-local opening equality interpreter
 no giant per-expression operand constants after compaction
 stage files are mostly declarative plan data
+generated functions are rustfmt-formatted and scan-friendly
+execution-relevant plan fields are typed unless explicitly allowlisted
+relation dispatch string sites trend to zero
+field-expression formula strings trend to zero
 ```
 
+LOC gates are guardrails, not the quality definition. A shorter verifier that
+hides semantics in opaque runtime code or compiler-only conventions fails this
+goal. The Tier A and Tier B ceilings are independently enforced so cleanup
+work cannot accidentally grow the audited Jolt math while shrinking generic
+scaffolding (or vice versa).
+
 Security and boundary gates:
 
 ```text
@@ -318,8 +564,41 @@ no kernel attrs in verifier CPU IR
 all transcript-producing ops thread transcript state
 all opening batches preserve explicit ordered claims
 all relation dispatch is typed or allowlisted
+missing proof data returns typed verifier errors
+duplicate or inconsistent opening claims reject explicitly
+name-then-position eval fallback is absent from verifier execution
 ```
 
+Performance gates:
+
+```text
+existing SHA2-chain core-vs-Bolt perf oracles remain runnable and green
+before/after verifier-time baseline recorded for interpreter-heavy slices
+repeatable verifier-time regressions are fixed or explicitly approved
+perf thresholds are not loosened to land readability refactors
+```
+
+Current perf evidence from May 16, 2026 on `quang/bolt-stack`:
+
+```text
+2^16 SHA2-chain oracle, 1 sample: passed
+  verify_ms ratio: 1.090x
+  prove_ms ratio: 0.856x
+
+2^20 SHA2-chain oracle, 1 sample: passed
+  verify_ms ratio: 1.124x
+  prove_ms ratio: 1.298x against 1.300x gate
+
+2^20 SHA2-chain oracle, 3 samples: passed
+  verify_ms ratio: 1.089x
+  prove_ms mean ratio: 1.168x, 95% CI [0.876x, 1.460x]
+```
+
+The previous hard perf blocker has moved out of the immediate blocker column:
+current oracles are green, and the latest 2^20 three-sample mean is below the
+threshold. The confidence interval still crosses the threshold, so future
+interpreter-heavy slices should continue to rerun it.
+
 Semantic gates:
 
 ```bash
@@ -342,6 +621,18 @@ core and Bolt reject equivalent tampered proofs
 generated prover/verifier crates stay in sync with artifact rail
 ```
 
+Subjective readability gate:
+
+```text
+blind reviewers can identify stage claims, transcript events, openings,
+sumcheck drivers, relation checks, and error paths from emitted Rust alone
+reviewers do not need to inspect Bolt lowering or emitter code to understand
+the generated verifier's security boundary
+reviewers prefer the new generated verifier shape over the current generated
+shape for auditability, or remaining objections are converted into tracked
+cleanup items
+```
+
 Perf remains a regression guard, not the center of this task. The existing
 `sha2-chain` e2e/proving Perfetto traces are useful for confirming cleanup does
 not accidentally move prover cost, but the main objective is verifier
@@ -371,7 +662,10 @@ score =
 + fewer generated helper bodies
 + stronger negative oracles
 + clearer verifier.rs
++ clearer stage files under blind review
++ more verifier facts represented as typed plans
 - semantic opacity introduced into runtime
+- compiler-context required to audit emitted Rust
 ```
 
 ## Definition Of Done
@@ -384,10 +678,13 @@ verifier.rs is <= 500 LOC
 stage files are mostly declarative plans
 generic verifier mechanics live once
 Jolt relation semantics are typed and auditable
+field expressions and program steps use typed plan data
+remaining string symbols are diagnostic or explicitly allowlisted
 MLIR verifier pathway has malformed-input rejection tests
 tamper suite covers commitments, transcript, stages, openings, evals, and PCS proof
 core/Bolt accept/reject equivalence is preserved
 generated verifier import boundaries are enforced
+independent blind readability review passes
 ```
 
 The desired end state is not merely fewer lines. The verifier should be easy to
diff --git a/crates/bolt/PROVER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/PROVER_PROGRAM_REFACTOR_PLAN.md
new file mode 100644
index 0000000000..81c21ba140
--- /dev/null
+++ b/crates/bolt/PROVER_PROGRAM_REFACTOR_PLAN.md
@@ -0,0 +1,421 @@
+# Prover Program Refactor Plan
+
+This is the prover-side companion to `crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md`.
+It asks which parts of the readable emitted-verifier work should also apply to
+generated prover Rust, and where the prover needs a different shape.
+
+The short answer is: the design philosophy transfers almost completely, but the
+mechanics do not transfer one-for-one. The verifier refactor is now explicitly
+pass-first and runtime-second: typed planning passes should resolve semantics
+before Rust emission, and runtime crates should contain only boring reusable
+mechanics. The prover should mirror that philosophy, but not by copying the
+verifier runtime shape.
+
+The prover already delegates much of its execution to `jolt-kernels`, so its
+main readability problem is not hand-written helper logic in generated files.
+It is large, expanded, stage-local, and partially stringly plan data. Markos'
+assessment matches this: prover codegen is currently easier because it mostly
+calls big kernels; verifier remains the priority because CPU-to-Rust verifier
+emission still does too much semantic work.
+
+The desired prover architecture is therefore:
+
+```text
+MLIR / Bolt IR owns protocol facts
+        |
+        v
+prover planning passes
+        |
+        v
+typed CPU / Rust-plan IR
+        |
+        v
+thin generated Rust const data
+        |
+        v
+efficient prover kernels and executors
+```
+
+The generated prover should remain an auditable declaration of what the prover
+does, not a pile of reconstructed protocol logic and not an opaque call into a
+black box.
+
+## Current observations
+
+The verifier refactor plan targets generated verifier stages that historically
+embedded a lot of semantic checking logic. By contrast, prover stages such as
+stage 5 already have the right broad shape: a static program plan plus a thin
+entry point that calls a kernel executor.
+
+The prover-side pain is concentrated elsewhere:
+
+- Some generated prover stages are still very large. A recent scan put
+  `crates/jolt-prover/src/stages/stage6.rs` at roughly 2,525 LOC and
+  `crates/jolt-prover/src/stages/stage7.rs` at roughly 1,940 LOC.
+- Much of the bulk appears to come from repeated opening inputs, evals, claim
+  rows, batch rows, and per-stage plan tables.
+- Prover plan types are stage-local and kernel-owned today, for example through
+  `jolt_kernels::stageN::{...}`.
+- Several fields still look more like serialized strings than typed execution
+  contracts.
+- The prover has an intentionally different import boundary than the verifier:
+  the verifier should avoid depending on prover and kernel crates, while the
+  prover is expected to call `jolt-kernels`.
+
+This means the prover refactor should optimize for compact typed plans over
+efficient kernels, not for replacing prover kernels with a generic verifier-like
+interpreter.
+
+This also means prover work should not compete with verifier-side CPU-to-Rust
+planning. The best near-term prover contribution is to avoid divergence: share
+typed plan vocabulary where it is genuinely common, move polynomial helpers to
+`jolt-poly`, and keep prover generated Rust from growing new stringly execution
+contracts while verifier planning is being cleaned up.
+
+## Guiding principle
+
+> The prover generated Rust should be readable protocol data over efficient
+> kernels. Planning passes should own semantic assembly; Rust should only
+> project typed prover plans and call the execution layer.
+
+Concrete corollaries:
+
+1. **MLIR owns semantic facts.** If prover execution depends on a relation,
+   opening family, batching rule, transcript event, or claim dependency, that
+   fact should exist as typed IR before the Rust emitter sees it.
+2. **Planning passes own semantic assembly.** The gap between `cpu` and emitted
+   Rust should be filled by explicit prover-planning passes when the current
+   direct emission path starts carrying semantic decisions.
+3. **Generated Rust is a projection.** The emitter should not reconstruct
+   prover semantics by parsing symbol names, matching prefixes, or expanding
+   regular families into hundreds of nearly identical rows when a typed family
+   plan would say the same thing.
+4. **Prover kernels stay hot-path aware.** Do not move prover relation logic
+   into a generic interpreter merely to shrink emitted Rust. Any abstraction
+   around prover execution must preserve the current performance model unless
+   benchmark data justifies a change.
+5. **Typed handles beat strings.** Strings are acceptable for diagnostics and
+   serialization names. Execution contracts should use enums, typed symbols,
+   typed family IDs, or structured plan fields.
+6. **Polynomial utilities come from `jolt-poly`.** If prover kernels or emitted
+   plans need equality, less-than, identity, Lagrange, indexed equality, or
+   projected-bit polynomial helpers, use or add the right primitive in
+   `jolt-poly` rather than duplicating it in `jolt-kernels` or generated Rust.
+7. **Compactness must stay auditable.** A range or family plan is good when it
+   exposes structure such as "all `InstructionRa` openings." It is bad if it
+   hides protocol meaning behind clever emitter-only conventions.
+8. **No compatibility shadows.** When replacing a string path or expanded table
+   with a typed plan, perform the full cutover for that surface rather than
+   keeping old and new forms in parallel.
+
+## What transfers from the verifier refactor
+
+### MLIR-owned semantics
+
+This applies fully. The same reason verifier math should not be reconstructed
+inside Rust templates also applies to prover execution metadata. The prover
+should receive typed plan rows that are already semantically meaningful.
+
+Examples:
+
+- relation and kernel IDs
+- transcript absorb and squeeze events
+- sumcheck driver schedules
+- opening inputs and opening claim groups
+- eval families and indexed eval addressing
+- batching structure
+- proof-record slots
+
+### Typed program plans
+
+This applies strongly, but the plan should be prover-shaped. A verifier program
+asks how to check proof data. A prover program asks how to generate proof data
+from witness-backed executors and kernels.
+
+The target should look more like:
+
+```rust
+pub struct ProverProgramPlan {
+    pub params: ProverParams,
+    pub steps: &'static [ProverStepPlan],
+    pub transcript_events: &'static [TranscriptEventPlan],
+    pub sumchecks: &'static [ProverSumcheckDriverPlan],
+    pub opening_inputs: &'static [OpeningInputPlan],
+    pub opening_families: &'static [OpeningFamilyPlan],
+    pub opening_batches: &'static [OpeningBatchPlan],
+    pub kernels: &'static [KernelInvocationPlan],
+}
+
+pub enum ProverStepPlan {
+    ExecuteKernel { kernel: KernelInvocationId },
+    AbsorbTranscript { event: TranscriptEventId },
+    SqueezeTranscript { output: ChallengeId },
+    ProveSumcheck { driver: ProverSumcheckDriverId },
+    EmitOpeningClaims { batch: OpeningBatchId },
+}
+```
+
+This is a sketch, not a locked API. The important part is that the generated
+file declares a typed execution plan rather than emitting stage-shaped Rust
+logic or enormous flat arrays when the protocol structure is regular.
+
+### Runtime extraction
+
+This applies only after the plan vocabulary is clearer, and not through
+`bolt-verifier-runtime`.
+
+The verifier plan has shifted away from "create a runtime first" and toward
+"create typed planning passes first." The prover should follow the same rule.
+A prover runtime crate is useful only if it owns boring execution mechanics
+over `jolt-kernels`; it should not become a second place to encode prover
+semantics.
+
+The prover should either use a dedicated prover runtime crate or a shared plan
+crate that contains only concepts genuinely common to prover and verifier. The
+verifier runtime has verifier-specific concerns such as expected-output checks,
+accept-reject behavior, and PCS verification boundaries. Those should not leak
+into prover APIs.
+
+Candidate crate boundaries:
+
+- `bolt-plan-runtime`: shared typed plan primitives, IDs, value domains, family
+  plans, transcript event plans, and opening/batch descriptors.
+- `bolt-prover-runtime`: prover-specific execution plan interpretation over
+  `jolt-kernels`.
+- `bolt-verifier-runtime`: verifier-specific proof checking over typed verifier
+  plans.
+
+The concrete crate split should be decided only after identifying the repeated
+plan structs and duplicated concepts in generated prover and verifier surfaces.
+Do not create `bolt-prover-runtime` just to move code out of generated files.
+First add metrics and planning seams that prove the shared surface is real.
+
+### Readability and LOC gates
+
+This applies directly, with prover-specific metrics.
+
+The verifier cleanup tests should inspire a prover cleanup test that tracks:
+
+- generated prover stage LOC
+- largest static table sizes
+- number of emitted stringly execution fields
+- number of stage-local plan structs or duplicate aliases
+- helper function count inside generated prover stages
+- generated prover surface LOC versus kernel/runtime LOC
+
+The goal is not to minimize total workspace LOC blindly. The goal is to move
+semantic bulk into typed, reusable, audited plan/runtime concepts and reduce
+generated-stage noise.
+
+### Subjective readability review
+
+This applies, but the review packet should include both the generated prover
+stage and the relevant kernel ABI. For the prover, semantics are intentionally
+split between plan data and execution kernels. A fair readability review should
+ask whether a reviewer can understand what proof work is scheduled without
+reading Bolt lowering code.
+
+## What does not transfer directly
+
+### The verifier import boundary
+
+The verifier should not depend on `jolt-prover`, `jolt-kernels`, or `jolt-core`
+implementation details. The prover has the opposite expectation: it is the
+proof-producing side and should call optimized kernel executors.
+
+So the prover contract should not say "no `jolt-kernels`." It should say:
+
+- generated prover Rust may depend on prover runtime and kernel crates;
+- generated prover Rust should not reconstruct kernel semantics locally;
+- kernel ABI rows should be typed, grouped, and auditable.
+
+### Verifier output-claim checks
+
+Verifier-side output-claim plans check that proof data is consistent with
+expected scalar values. The prover analogue is not to verify those claims, but
+to declare produced claims, openings, batches, and transcript dependencies in a
+typed way.
+
+The shared abstraction is the vocabulary of claims, openings, eval families, and
+relations. The execution meaning is side-specific.
+
+### Generic interpretation of hot prover math
+
+The verifier can afford more generic interpretation because its workload is
+small relative to proving. The prover cannot assume that. Any move from
+specialized kernels to generic interpreters requires explicit profiling and a
+clear reason beyond generated Rust readability.
+
+## Proposed slices
+
+### P0: Mirror verifier cleanup only where it is already shared
+
+Do this opportunistically while verifier remains the priority.
+
+- Move duplicated polynomial helpers in verifier runtime, `jolt_relations`, and
+  `jolt-kernels` toward `jolt-poly`.
+- Keep prover generated Rust compatible with the typed plan vocabulary that the
+  verifier planning passes introduce.
+- Avoid adding a prover runtime crate until repeated plan/execution mechanics
+  are visible and measured.
+
+This is the safest prover-side work while Markos is changing higher dialects and
+the verifier CPU-to-Rust planning path is still moving.
+
+### P1: Add prover generated-surface cleanup metrics
+
+Add a prover-side cleanup test parallel to the verifier cleanup test. It should
+initially report and gate the current generated surface without changing
+execution.
+
+Suggested metrics:
+
+- per-stage generated prover LOC
+- stage 6 and stage 7 static table sizes
+- count of stringly plan fields that affect execution
+- count of emitted helper functions in generated stages
+- count of duplicated stage-local plan structs
+
+The purpose of P1 is visibility. It should make the prover readability problem
+concrete before changing plan APIs.
+
+### P2: Identify and type the largest repeated plan families
+
+Inspect the largest generated tables in prover stages 6 and 7 and classify
+which rows are regular families.
+
+Likely candidates:
+
+- `InstructionRa_*` opening groups
+- lookup-table flag families
+- repeated eval plans
+- opening claim groups
+- opening batch membership
+- point slice and concat patterns
+
+Replace regular expanded rows with explicit family or range plans only when the
+family name, bounds, and derivation are visible in generated Rust.
+
+### P3: Introduce typed prover plan IDs and enums
+
+Remove string-backed execution contracts from prover plan rows where those
+strings affect behavior. Prefer closed enums, typed IDs, and typed symbols.
+
+This should cover fields such as:
+
+- kernel kind and ABI
+- step kind
+- claim kind
+- field expression kind
+- relation or source kind
+- opening family kind
+
+When a typed path lands, delete the string path in the same slice.
+
+This should be implemented through prover planning data where possible, not by
+teaching the Rust emitter more string-to-token mappings.
+
+### P4: Add prover CPU-to-Rust planning seams
+
+After P1-P3 identify the repeated structures, add explicit prover planning
+passes between CPU IR and emitted Rust. These passes will differ from the
+verifier passes because prover execution is kernel-backed and witness-backed.
+
+Likely passes:
+
+- `plan-prover-kernel-invocations`: typed kernel IDs, ABI rows, executor data
+  requirements, and output artifact contracts.
+- `plan-prover-sumchecks`: typed driver/batch/claim/opening plans for proof
+  production.
+- `plan-prover-opening-flow`: typed opening inputs, produced claims, opening
+  batches, and transcript dependencies.
+- `plan-prover-families`: compact repeated opening/eval/claim rows into named
+  families and ranges.
+
+The Rust emitter should consume those plans directly rather than rediscovering
+kernel/proof semantics from CPU op attrs.
+
+### P5: Factor common plan vocabulary
+
+After P2-P4 reveal the real common surface, factor shared plan primitives out of
+stage-local modules.
+
+Good shared candidates:
+
+- typed symbol and ID wrappers
+- transcript event plans
+- opening input descriptors
+- opening family descriptors
+- opening batch descriptors
+- field expression descriptors
+- eval-family descriptors
+
+Do not prematurely force prover and verifier to share side-specific execution
+types. Shared vocabulary is good; shared accidental abstractions are not.
+
+### P6: Move toward a top-level prover program
+
+Once per-stage plans are compact and typed, consider a top-level
+`JoltProverProgramPlan` that schedules the proof-producing flow across stages.
+
+This should remain secondary to P2-P5. The prover has witness state, executor
+state, and hot kernels that make top-level orchestration more complex than the
+verifier case. A top-level plan is useful if it clarifies scheduling and proof
+record layout; it is not useful if it merely wraps existing stage calls in a
+new layer.
+
+## Non-regression contracts
+
+1. **Readability cannot regress.** Generated prover Rust should become easier
+   to audit as proof work, not merely shorter.
+2. **Performance cannot silently regress.** Prover kernels are hot-path code.
+   Any interpreter-heavy or dispatch-heavy change needs benchmark coverage or
+   explicit approval.
+3. **Generated LOC should trend down.** Temporary LOC growth is acceptable only
+   if it replaces opaque template logic with typed declarative plan data and has
+   a clear path to reducing generated-stage noise.
+4. **Kernel semantics must stay single-sourced.** Do not duplicate kernel math
+   in generated Rust for readability.
+5. **No compatibility shims.** Full cutover for each changed plan surface.
+6. **Equivalence and proof serialization must remain stable unless explicitly
+   scoped.** A readability refactor should not change proof semantics or record
+   layout by accident.
+7. **Verifier priority remains explicit.** Prover refactor slices should not
+   block or complicate verifier CPU-to-Rust planning unless they remove shared
+   duplication, especially in `jolt-poly`.
+
+## Implementation readiness
+
+The most implementation-ready path is:
+
+1. Reuse or add the missing `jolt-poly` helpers that both verifier and prover
+   need.
+2. Add prover cleanup metrics.
+3. Use those metrics to lock the current stage 6 and stage 7 generated-surface
+   baseline.
+4. Classify repeated plan rows into named families.
+5. Replace the largest safe repeated families with typed family plans.
+6. Type the remaining string-backed execution fields through planning data,
+   not emitter-local token maps.
+
+This path is valuable even if the final top-level prover program is deferred.
+It attacks the current readability problem directly while preserving the
+existing prover execution model.
+
+## Open questions
+
+- Should shared plan concepts live in a neutral `bolt-plan-runtime` crate, or
+  should prover and verifier each own their own runtime crate until the common
+  surface is clearer?
+- Which prover facts should become planning-pass output versus remaining kernel
+  ABI data?
+- Which stage 6 and stage 7 expansions are purely regular families, and which
+  encode irregular protocol decisions that should remain explicit rows?
+- What prover benchmark should become the repeatable perf baseline for these
+  slices?
+- How much of the prover stage shape is proof-record layout that should remain
+  numbered, versus historical scaffolding that can become a top-level program?
+
+The working bias should be conservative: first make the generated prover's
+existing structure visible and typed, then decide whether a broader top-level
+program refactor buys enough clarity to justify its cost.
diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md
new file mode 100644
index 0000000000..1b3e65f091
--- /dev/null
+++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md
@@ -0,0 +1,1315 @@
+# Verifier Program Refactor Plan
+
+This is the implementation plan for the verifier-program refactor. It is a
+companion to `crates/bolt/GOAL.md`. Read GOAL.md first; this document assumes
+the `Audit Tiers` framing introduced there, but the scope is broader than
+follow-up LOC cleanup.
+
+The target is a complete refactor of how the generated verifier is constructed,
+compiled, and emitted. The current stage-shaped Rust is useful reference
+material, but it is not the desired architecture. The desired architecture is a
+typed verifier program: an ordered plan of verifier steps over commitments,
+transcript events, sumcheck drivers, value-graph computations, opening batches,
+and PCS checks.
+
+S1 (the audit-tier split that landed in PR #1523) reframes the shared
+verifier runtime as explicitly-bounded tiers:
+
+```text
+Tier A (Bolt verifier runtime)        bolt-verifier-runtime/src/lib.rs   ~2.5k LOC
+Tier B (audited Jolt verifier core)   stages/jolt_relations.rs             696 LOC
+Tier C (generated stage data + verifier.rs)                              ~6.1k LOC
+```
+
+The current stack has already moved beyond the original S1 framing:
+
+- `bolt-verifier-runtime` exists as a standalone crate.
+- `JoltRelationKind` is owned by the Jolt verifier layer instead of the generic
+  runtime.
+- Generated stages use typed relation enums instead of relation `&'static str`
+  dispatch.
+- The top-level verifier executes a typed verifier-program plan.
+- Structured relation-output and polynomial-eval plans have started replacing
+  handwritten verifier math.
+
+The remaining plan is therefore **pass-first, runtime-second**. The primary
+goal is not to grow a larger verifier runtime. The primary goal is to make
+verifier construction a typed planning pipeline whose final Rust emission is
+nearly mechanical:
+
+```text
+protocol / compute IR
+        |
+        v
+verifier planning passes
+        |
+        v
+typed CPU / Rust-plan IR
+        |
+        v
+dumb Rust emission
+        |
+        v
+small runtime crates for boring reusable mechanics
+```
+
+## Guiding principle
+
+> Verifier semantics should be resolved before Rust emission. Runtime crates are
+> allowed only for boring, reusable execution mechanics.
+
+Concrete corollary: **`bolt-verifier-runtime` is not the architecture.** It is a
+useful crate for verifier-program execution, typed value interpretation,
+transcript/sumcheck/opening plumbing, and error structure. It should not become
+the bucket where all common generated verifier Rust goes. If a fact is semantic,
+it belongs in MLIR/codegen planning or in an explicit protocol boundary, not in a
+runtime helper that reconstructs meaning from strings.
+
+Numbered stages may remain as proof-layout slots and diagnostic scopes, but
+they should not remain the verifier's core execution model. A generated
+verifier should answer "what verifier program is executed?" rather than "how
+many stage modules are hardcoded?"
+
+## Design thesis: typed verifier IR, not better templates
+
+The plan should not optimize for making today's Rust templates shorter. The
+real target is a typed verifier-planning pipeline whose Rust rendering is
+nearly a serialization detail:
+
+1. **MLIR owns semantic facts.** If verifier execution depends on a fact, the
+   fact should exist as a dialect op, typed attr, or typed plan field before the
+   Rust emitter sees it.
+2. **Planning passes own semantic assembly.** The gap between `cpu` and emitted
+   Rust should be filled by explicit verifier-planning passes, not by ad hoc
+   emitter parsing.
+3. **The Rust emitter projects typed plans.** It should not reconstruct protocol
+   meaning by parsing symbols, matching string prefixes, or emitting bespoke
+   helper bodies that duplicate protocol math.
+4. **Symbols are typed handles.** Examples in this document use `&'static str`
+   where that keeps the prose readable, but implementation APIs should prefer
+   `TypedPlanSymbol<Tag>`-style references. Plain strings are diagnostics and
+   serialization names, not execution contracts.
+5. **The runtime interprets typed value domains.** Scalars, points, field
+   vectors, eval families, relation outputs, and bytecode encodings are
+   different verifier value kinds. Do not force point transforms or vectors into
+   `FieldExprKind` just because field expressions exist today.
+6. **Relations should be scheduled dataflow, not a second DSL.** Prefer one
+   typed verifier value graph over separate mini-interpreters for field
+   expressions, point expressions, eval families, and relation terms. A relation
+   check should usually be "the expected sumcheck output is scalar value X"
+   where X is produced by the same typed graph as other verifier values.
+7. **Protocol vocabulary stays at the protocol boundary.** Generic runtime code
+   may carry opaque IDs or be generic over protocol-specific enums, but it
+   should not define Jolt relation variants such as `Stage6BytecodeReadRaf`.
+8. **Polynomial utilities come from `jolt-poly`.** If verifier math needs
+   equality, less-than, identity, Lagrange, indexed equality, or projected-bit
+   polynomial helpers, first use or add the right primitive in `jolt-poly`.
+   Do not reimplement those helpers in generated verifier Rust or runtime code.
+9. **No fallback execution paths.** When a typed path lands, delete the string
+   path in the same slice. Rollback by reverting the slice, not by keeping a
+   compatibility parser in the verifier.
+10. **Auditability beats clever compaction.** A generated table that is longer
+   but explains the verifier contract is better than a short table whose
+   meaning only appears in the emitter.
+
+## Verifier program model
+
+The long-term emitted boundary should look like typed verifier-program data,
+not a sequence of bespoke `verify_stageN` functions:
+
+```rust
+pub struct VerifierProgramPlan {
+    pub params: VerifierParams,
+    pub steps: &'static [VerifierStepPlan],
+    pub values: &'static [ValuePlan],
+    pub sumchecks: &'static [SumcheckDriverPlan],
+    pub openings: &'static [OpeningClaimPlan],
+    pub opening_batches: &'static [OpeningBatchPlan],
+    pub pcs_checks: &'static [PcsCheckPlan],
+}
+
+pub enum VerifierStepPlan {
+    ReceiveCommitments { batch: CommitmentBatchId },
+    TranscriptAbsorb { event: TranscriptEventId },
+    TranscriptSqueeze { output: ValueId },
+    EvaluateValues { until: ValueId },
+    VerifySumcheck { driver: SumcheckDriverId },
+    EmitOpeningBatch { batch: OpeningBatchId },
+    VerifyPcsOpening { check: PcsCheckId },
+}
+```
+
+`SumcheckDriverPlan` is the central verifier concept. It should contain the
+proof slot, round schedule, input-claim plan, batching plan, relation-output
+plan, value/eval observation, expected-output scalar, and opening-claim emission
+for one sumcheck driver. Planning passes should assemble this shape before Rust
+emission. The runtime should not need to rediscover whether a driver came from
+"Stage 3" or "Stage 6" except for diagnostics and proof-record layout.
+
+Commitment receipt and PCS opening verification are first-class verifier steps,
+not synthetic stages. Partial verification targets should eventually be named
+checkpoints or proof slots, not `through_stage5` / `through_stage6` booleans.
+
+## Non-regression contracts
+
+This refactor is allowed to move code across boundaries, but it is not allowed
+to make the verifier harder to audit, larger at the finish line, slower without
+an explicit decision, or weaker semantically.
+
+1. **Readability cannot regress.** Every slice must preserve or improve the
+   ability to audit generated Rust without reading Bolt lowering code. The final
+   stack must pass an independent readability review where reviewers see the
+   current verifier surface and the new generated verifier surface, but not the
+   compiler implementation.
+2. **LOC cannot regress at completion.** The completed stack must not exceed the
+   locked post-S1 generated-verifier baselines in `GOAL.md`, and the intended
+   trajectory is downward. Temporary slice-local LOC growth is acceptable only
+   when it moves hand-written protocol math into declarative typed plan data,
+   is called out in the PR, and does not weaken the final LOC target.
+3. **Performance cannot silently regress.** Existing core-vs-Bolt perf oracles
+   are useful smoke gates, but their current thresholds are intentionally broad.
+   Before interpreter-heavy slices land, capture a verifier-time baseline and
+   gate repeated regressions. A repeatable verifier regression must either be
+   fixed, justified as the price of a specific readability/security gain, or
+   explicitly approved before landing.
+4. **Semantic and tamper behavior cannot regress.** Core/Bolt accept-reject
+   equivalence, transcript state agreement, opening equality behavior, and PCS
+   verification must stay covered by positive and negative oracles.
+5. **No compatibility shadows.** Do not keep old stage-local execution paths as
+   fallbacks once typed verifier-program execution lands. Rollback by reverting
+   the slice, not by leaving dual interpreters in the verifier.
+
+## Scoreboard (target trajectory)
+
+| Slice | Tier A | Tier B | Tier C | jolt-verifier total | Notes |
+|-------|-------:|-------:|-------:|--------------------:|-------|
+| post-S1 (today) | 1,265 | 638 | 6,430 | 7,905 | hard ceilings: A 1,400 / B 700 / C surface 6,100 |
+| current stack | ~0 in generated crate | <=700 | bounded by cleanup gates | bounded by cleanup gates | runtime extraction, typed relations, top-level verifier program, relation-output plans |
+| next pass-first slice | narrow runtime | <=700 | stable or lower | stable or lower | classify runtime/codegen/poly ownership and add planning-pass seams |
+| value graph | narrow runtime | <=638 | ~6,300-6,500 | ~6,500 | typed scalar/point/vector/eval-family plans |
+| eval families | narrow runtime | ~350 | ~6,500 | ~6,500 | typed indexed-eval addressing |
+| relation plans | narrow runtime | ~290 | ~6,700 | ~6,700 | relations as typed plans (Tier C may grow temporarily) |
+| bytecode encoding | narrow runtime | ~50 | ~6,800 | ~6,800 | optional, only if audit pressure justifies it |
+
+Scoreboard numbers are planning targets for individual slices. The
+non-regression contracts above are stricter: the completed stack must not end
+larger, less readable, slower without approval, or semantically weaker than the
+post-S1 baseline.
+
+---
+
+## S2: Runtime extraction status and boundary correction
+
+**Status.** The current stack has already performed the main extraction:
+`bolt-verifier-runtime` is a standalone workspace crate, generated
+`jolt-verifier` depends on it, and Tier A is no longer emitted as
+`stages/common.rs`.
+
+**Revised goal.** Keep that progress, but treat the crate as provisional and
+narrow. The runtime is useful for boring verifier-program mechanics, but it
+must not become the place where all shared generated verifier Rust accumulates.
+The remaining S2 work is classification and boundary correction:
+
+- keep generic verifier-program sequencing, value interpretation,
+  transcript/sumcheck/opening plumbing, and structural error types in
+  `bolt-verifier-runtime`;
+- keep `JoltRelationKind`, bytecode contracts, RAM/register/lookup semantics,
+  point normalizations tied to Jolt proof layout, and other protocol math in the
+  Jolt layer or in typed MLIR/codegen plans;
+- move reusable polynomial helpers to `jolt-poly` instead of implementing them
+  in the runtime;
+- add CPU-to-Rust planning seams so future semantics move into passes instead
+  of runtime helpers or Rust emitter logic.
+
+### Locked decisions already reflected by the current stack
+
+- `bolt-verifier-runtime` is a standalone workspace crate at
+  `crates/bolt-verifier-runtime/`. It is not a sub-crate of `bolt` and is not
+  re-exported through `bolt`.
+- Relation IDs use generic enum parameterization, not opaque string-backed
+  symbols. Relations are used for verifier dispatch, so a closed protocol enum
+  gives exhaustive-match pressure and keeps strings out of execution contracts.
+- The generic runtime owns the relation trait and generic plan structs. The
+  Jolt layer owns the closed relation enum:
+
+  ```rust
+  pub trait ProtocolRelation: Copy + Eq + core::fmt::Debug + 'static {}
+  impl<T: Copy + Eq + core::fmt::Debug + 'static> ProtocolRelation for T {}
+
+  pub struct SumcheckClaimPlan<R: ProtocolRelation> {
+      pub relation: Option<R>,
+      // ...
+  }
+
+  pub struct SumcheckDriverPlan<R: ProtocolRelation> {
+      pub relation: Option<R>,
+      // ...
+  }
+
+  pub struct SumcheckInstanceResultPlan<R: ProtocolRelation> {
+      pub relation: R,
+      // ...
+  }
+  ```
+
+  `JoltRelationKind` lives in the generated Jolt verifier's
+  `jolt_relations` module, and stage files alias it as
+  `StageNRelationKind`. `TypedPlanSymbol<Tag>` remains useful for value,
+  opening, claim, and diagnostic symbols, but not for relation dispatch.
+- `SourceStage` is not part of the generic runtime. Stage 8 gets a local
+  `Stage8SourceStage` enum until the later PCS-opening plan model removes the
+  source-stage special case entirely.
+- Per-stage type aliases are not load-bearing. Keep or delete them based on
+  readability after the import cutover, but do not preserve them as API
+  compatibility shims.
+
+### Runtime boundary classification
+
+Keep in `bolt-verifier-runtime` only when the code is protocol-neutral
+execution machinery:
+
+- top-level verifier-program sequencing;
+- typed plan records for transcript events, sumcheck drivers, opening claims,
+  opening batches, and PCS checks;
+- `ValueStore`-style typed value interpretation once value domains are
+  explicit;
+- generic sumcheck verification loops;
+- opening equality checks and transcript append mechanics;
+- structural error reporting that can be parameterized by protocol IDs.
+
+Do not add to `bolt-verifier-runtime` when the code depends on Jolt protocol
+meaning:
+
+- `JoltRelationKind` variants;
+- bytecode row contracts and lookup-table semantics;
+- Stage 2 RAM/product/instruction-lookup algebra;
+- Stage 5 instruction read-RAF algebra;
+- Stage 6/7 bytecode, hamming, RA, inc-reduction, and point-normalization
+  semantics;
+- string-prefix eval-family lookup as a permanent API.
+
+If a helper is polynomial math rather than verifier mechanics, prefer
+`jolt-poly`. Current candidates include less-than MLE evaluation, identity
+polynomial evaluation, Lagrange basis evaluation, indexed Boolean equality, and
+projected/operand polynomial evaluation.
+
+### Concrete plumbing already done or retained
+
+1. New crate `crates/bolt-verifier-runtime/` with `src/lib.rs` seeded from
+   the old verifier-common template, but reviewed as a public runtime API
+   rather than copied verbatim. At minimum: cross-crate paths, the
+   error-conversion macro, and protocol-ID ownership must be corrected during
+   the move.
+2. Workspace `Cargo.toml` registers the new crate.
+3. `crates/bolt/src/protocols/jolt/artifacts.rs::verifier_runtime_modules`
+   stops emitting the `common` module (the `ProtocolRuntimeModule` entry
+   for `common` is removed). The `jolt_relations` entry stays.
+4. Stage emitters (`crates/bolt/src/protocols/jolt/emit/rust/stage{1..8}.rs`)
+   change `super::common::{...}` imports to
+   `bolt_verifier_runtime::{...}`. The `super::jolt_relations::{...}`
+   imports are unchanged.
+5. The Bolt manifest emitter (the part of `artifacts.rs` that writes the
+   generated `Cargo.toml` for `jolt-verifier`) adds a `bolt-verifier-runtime`
+   dependency entry, mirroring how `jolt-field`, `jolt-poly`, etc. are
+   already wired.
+6. `crates/jolt-verifier/src/stages/common.rs` is deleted from the goldens.
+   `crates/jolt-verifier/src/stages/mod.rs` drops `pub mod common;`. Do not
+   leave a `jolt_verifier::stages::common` compatibility re-export; update every
+   call site in the same slice.
+7. `crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs` and the
+   oracle modules update their `use jolt_verifier::stages::common::*`
+   imports to `use bolt_verifier_runtime::*`.
+8. Move `RelationKind` out of Tier A and into the Jolt layer as
+   `JoltRelationKind`. Genericize relation-bearing runtime structs over
+   `R: ProtocolRelation`.
+9. Move `SourceStage` out of Tier A. Stage 8 defines a local source-stage enum
+   until S2.5/S4/S5 replace that source lookup with typed verifier-program /
+   opening-batch data.
+
+### Follow-up cleanup created by this revision
+
+1. Rename the old "runtime extraction" milestone in future PR descriptions to
+   "runtime boundary narrowing" or "typed planning pipeline".
+2. Audit `bolt-verifier-runtime` for APIs that branch on strings or encode Jolt
+   protocol facts. Each such API needs one of three dispositions: typed planning
+   pass, Jolt verifier boundary, or `jolt-poly`.
+3. Replace runtime-local polynomial helpers with `jolt-poly` calls before adding
+   more runtime surface.
+4. Treat duplicate plan container variants in the runtime as transitional
+   emitter-shape leakage. Collapse them as the CPU-to-Rust plan layer becomes
+   explicit.
+5. Do not expand the runtime to compensate for missing MLIR/codegen passes.
+
+### Test/gate updates
+
+- Keep `verifier_cleanup.rs` focused on the generated verifier surface, but add
+  or retain a separate runtime ceiling so `bolt-verifier-runtime` cannot grow
+  quietly.
+- Keep `bolt-verifier-runtime` as the only intentional verifier runtime
+  dependency. The verifier remains forbidden from depending on `jolt-prover`,
+  `jolt-kernels`, `jolt-core`, `jolt-equivalence`, and tracing/profiling crates.
+- Add targeted checks for runtime APIs that branch on string contents. Those
+  sites should ratchet down as S2.75/S3/S4 land.
+- Add `jolt-poly` reuse checks when a helper is moved out of the runtime or
+  Jolt verifier core.
+
+### Remaining risks and complications
+
+- **Runtime surface creep.** The extraction solved generated-code duplication,
+  but the crate can still become too bespoke if it accepts every helper the
+  emitter wants. Treat every new runtime API as a boundary decision.
+- **String-keyed transitional APIs.** `ValueStore`, eval-prefix helpers,
+  point-order strings, and proof/source-stage strings are useful during the
+  transition, but they should be removed or typed as planning passes land.
+- **Duplicate plan containers.** Multiple near-duplicate stage plan structs are
+  signs that emitter shape leaked into the runtime. Collapse them once typed
+  planning output is explicit.
+- **Polynomial helper ownership.** Less-than, identity, Lagrange, indexed
+  equality, and projected-bit polynomial helpers belong in `jolt-poly`, not in
+  `bolt-verifier-runtime` or generated verifier Rust.
+- **Equivalence adapters.** Any plan-shape cleanup still has cross-crate blast
+  radius in `jolt-equivalence`; keep full-cutover discipline.
+
+### Acceptance criteria
+
+```text
+cargo check -p bolt -p bolt-verifier-runtime -p jolt-verifier
+            -p jolt-prover -p jolt-equivalence  --quiet
+cargo nextest run -p bolt --test verifier_cleanup --no-capture
+cargo nextest run -p bolt --test commitment_ir --cargo-quiet
+cargo nextest run -p jolt-equivalence --test generated_role_crates --cargo-quiet
+cargo nextest run -p jolt-equivalence --test bolt_commitment --no-capture
+```
+
+All green. The metrics output shows Tier A remains absent from the generated
+verifier crate, runtime LOC is explicitly bounded, and runtime string-dispatch
+sites are reported.
+
+### Rollback
+
+The extraction should not be rolled back unless the runtime boundary itself
+turns out wrong. If the boundary audit overreaches, revert the specific API
+deletion or helper movement rather than reintroducing generated `common.rs`.
+No data or proof-format changes are involved.
+
+### Estimated wall-clock
+
+Extraction has already happened. The remaining boundary audit is one focused
+agent slice, mostly classification, API deletion, `jolt-poly` reuse, and test
+gate updates.
+
+---
+
+## S2.5: Verifier-program executor status and next tightening
+
+**Status.** The current stack has introduced the typed top-level
+`VerifierProgramPlan` and routes verifier execution through it. Keep this shape.
+
+**Revised goal.** Tighten the source of truth. The top-level plan should be
+assembled by verifier-planning passes instead of stringly artifact glue or
+emitter-side stage scans. This slice remains architectural: it changes how the
+verifier is scheduled, not proof serialization.
+
+This does not require fully deleting stage modules immediately. Stage modules
+may still own proof-slot conversion and local plan constants at first. The
+important cutover is that the top-level verifier sees a program of typed steps,
+and `stageN` names become proof-slot labels rather than the verifier's control
+flow.
+
+### Concrete plumbing
+
+1. Add typed top-level verifier-program types:
+
+   ```rust
+   pub enum ProofSlot {
+       Commitments,
+       Stage1Outer,
+       Stage2,
+       Stage3,
+       Stage4,
+       Stage5,
+       Stage6,
+       Stage7,
+       Evaluation,
+   }
+
+   pub enum VerifierStepPlan {
+       ReceiveCommitments { slot: ProofSlot },
+       VerifyStage { slot: ProofSlot },
+       VerifyPcsOpening { slot: ProofSlot },
+   }
+
+   pub enum VerifierCheckpoint {
+       AfterStage5,
+       AfterStage6,
+       AfterStage7,
+       AfterEvaluation,
+   }
+
+   pub enum EvaluationPolicy {
+       Skip,
+       VerifyIfPresent,
+       Required,
+   }
+
+   pub struct VerifierTarget {
+       pub checkpoint: VerifierCheckpoint,
+       pub evaluation: EvaluationPolicy,
+   }
+   ```
+
+   `ProofSlot` is the protocol/proof-layout identity. `VerifierStepPlan` is the
+   execution identity. They should not be conflated.
+2. Represent commitment receipt, transcript absorbs/squeezes, sumcheck driver
+   verification, opening-batch emission, and PCS opening verification as program
+   steps.
+3. Keep `JoltProof` serialization unchanged:
+   `commitments`, `stage1_outer`, `stage2`, ..., `stage7`, `evaluation`.
+   The verifier program is execution metadata, not proof data.
+4. Replace the hardcoded stage call chain in `verifier.rs` with a loop over the
+   generated program. Existing `verify_stageN_with_program` functions remain as
+   slot executors during this slice, but there must be one execution path, not
+   old/manual and new/program paths side by side.
+5. Replace target APIs such as `through_stage5`, `through_stage6`, and
+   `through_stage7` with named checkpoints or proof-slot targets. The old names
+   can survive as user-facing constructors only if they are constants for the
+   new checkpoint values, not separate branches.
+6. Make stage artifacts addressable through an internal `ArtifactStore` keyed by
+   typed proof slots. Public `JoltVerificationArtifacts` keeps its current field
+   shape for this slice and is materialized from the store at the end so
+   downstream callers are not forced to migrate yet.
+7. Stage 8 becomes `VerifyPcsOpening { check }` plus supporting opening-batch
+   plans. It should not be special because it happens to be the eighth module.
+8. Keep stage-local error quality. Stage failures still map to
+   `JoltVerifyError::StageN`; only structural verifier-program failures use a
+   new top-level program error.
+
+### Acceptance criteria
+
+- `verifier.rs` no longer manually sequences every numbered stage as bespoke
+  control flow.
+- There is a checked-in generated `VERIFIER_PROGRAM` or equivalent top-level
+  const plan that a reviewer can scan.
+- Commitment handling, all current sumcheck stages, and PCS opening
+  verification appear as typed verifier steps.
+- Partial verification targets are typed checkpoints/proof slots.
+- No duplicate old/new verifier execution path remains.
+- Existing semantic, tamper, and import gates still pass.
+- Existing before/after verifier-time perf baselines remain attached to this
+  architectural change; future tightening slices should compare against them.
+
+### Blockers and complications
+
+- **Artifact typing.** Today's `JoltVerificationArtifacts` has hardcoded fields
+  for each stage. Moving to `ArtifactStore` risks hiding what each step
+  produces. The generated program should keep named artifact IDs and readable
+  comments/table rows so the dataflow remains auditable.
+- **Error mapping.** Stage-specific errors are useful diagnostics. Preserve
+  that quality by attaching proof-slot/checkpoint context to generic runtime
+  errors instead of flattening everything into one opaque error.
+- **Proof serialization.** This slice should not change proof format. It should
+  adapt the existing proof fields into typed proof slots.
+
+### Estimated wall-clock
+
+Two to three agent sessions. This is mostly control-flow architecture and
+artifact typing, not new protocol math. The current stack has already completed
+the main shape; remaining work belongs in S2.75 planning-pass tightening.
+
+---
+
+## S2.75: Add CPU-to-Rust verifier planning passes
+
+**Goal.** Insert an explicit planning layer between `cpu` IR and emitted Rust.
+This is the main course correction from Markos' feedback: do not make the Rust
+emitter or `bolt-verifier-runtime` responsible for discovering verifier
+semantics.
+
+The current `cpu` layer still carries protocol-plan material such as stages,
+proof slots, relation symbols, opening sources, point order, relation outputs, and
+PCS policies. That is acceptable as a transitional representation, but the
+Rust emitter should not parse those fields into execution meaning. It should
+consume a typed Rust-plan / verifier-plan representation produced by passes.
+
+### Proposed passes
+
+1. `resolve-cpu-program-steps`: materialize ordered program steps for
+   transcript events, sumcheck drivers, opening-batch emission, and PCS checks.
+2. `annotate-jolt-relations`: attach typed relation metadata before emission,
+   including relation kind, proof slot, output-evaluator strategy, external
+   verifier data requirements, and kernel ABI where relevant.
+3. `plan-verifier-sumchecks`: lower verifier sumcheck ops plus batches and
+   instance results into `SumcheckDriverPlan` rows.
+4. `plan-field-and-relation-outputs`: canonicalize field expressions, structured
+   polynomial evals, and relation-output equations into a typed scalar/point/value
+   graph.
+5. `plan-opening-flow`: resolve opening inputs, claims, equalities, batches,
+   point/eval sources, arities, and ordering.
+6. `plan-point-normalization`: replace `point_order` strings and stage-specific
+   point transforms with typed point-transform plans.
+7. `validate-rust-target-plan`: reject unsupported field/PCS/transcript
+   combinations, unresolved symbols, role-specific forbidden ops, and
+   relation/runtime-boundary violations before the emitter runs.
+
+### Acceptance criteria
+
+- New verifier semantics are added as planning-pass output, not as Rust emitter
+  parsing or new runtime string dispatch.
+- Relation strings are converted to typed relation IDs before Rust token
+  emission.
+- Relation-output and point-normalization planning can be inspected without
+  reading emitted Rust templates.
+- The Rust emitter's responsibility is mostly formatting typed const data and
+  importing the right runtime/Jolt-boundary APIs.
+
+### Current status
+
+The current stack has most of the typed planning data this section calls for:
+`VerifierStagePlan` owns stage-local scalar, point, vector, eval-family, and
+relation-output plan rows; generated Stage 2-7 code emits typed
+`RelationOutputPlan` data with closed relation IDs; and the Rust emitters
+increasingly consume typed refs rather than rebuilding meaning from raw strings.
+The shared
+`plan_verifier_stage_from_cpu_sources` entrypoint now makes the main S2.75
+boundaries explicit as named planning functions:
+`resolve_cpu_program_steps`, `plan_transcript_flow`,
+`plan_verifier_sumchecks`, `plan_field_and_relation_outputs`, and
+`plan_opening_flow`.
+
+Stage 5/6 relation-local input plans are also now produced through this shared
+planning boundary. Relation-output validation and verifier-mode sumcheck
+batch/driver consistency checks now run from `VerifierStagePlan` instead of
+repeated stage-local string sets and batch maps. Verifier-mode opening-flow
+checks for point sources, opening equalities, opening claims, sumcheck eval
+sources, and opening batches also run from `VerifierStagePlan`; prover
+`input_openings` checks remain stage-local because verifier runtime claim rows
+do not carry those fields.
+
+Stage 2 now shares the same compiler-side CPU row structs as Stage 3-7 and
+builds a `VerifierStagePlan` for verifier programs. Its verifier sumcheck,
+relation-output, and opening-flow checks run through the shared plan. The
+remaining S2.75 risk is no longer that Stage 2 lacks the typed planning
+boundary; it is that Stage 2 still contains a handwritten relation-output
+formula table whose operands are validated through the existing field/scalar
+flow checks. The next closeout step should be a completion audit that separates
+true remaining architecture work from gates: semantic/tamper behavior,
+host/zk e2e, and the fragile perf oracle.
+
+---
+
+## S3: Typed verifier value graph + polynomial primitives
+
+**Goal.** Introduce the typed verifier value graph and use it for the first
+relation-output checks. This is broader than Stage 6/7 helper cleanup: stages
+2-7 all contain handwritten expected-output math. The first conversions should
+be Stage 3 and Stage 4 because they exercise the value-graph path without RAM
+external data, bytecode rows, lookup-table families, or univariate-skip proof
+shape.
+
+The important design point is that this is not "add more variants to
+`FieldExprKind`"; it is a typed graph over scalar, point, field-vector, and
+eval-family values.
+
+### Current status
+
+The scalar/point source registry has been moved out of
+`verifier_relation_outputs` into `verifier_values`. This is only the foundation:
+it gives scalar and point domains an explicit home. `VerifierStagePlan` now
+carries enough scalar/point source data for Stage 3-7 relation-output validation
+and verifier opening-flow validation to consume plan-derived value sources
+instead of rebuilding point sources in each stage. Verifier field-flow
+validation also consumes plan-derived scalar sources; the remaining CPU scalar
+source builders are explicitly scoped to prover/role-neutral validation.
+Stage 5/6 verifier programs now also emit explicit indexed eval-family rows as
+runtime `NamedEvalFamilyPlan` slices and seed them into `ValueStore` as
+field-vector values after sumcheck output observation. Relation-output execution
+has started consuming those vectors: output product-family terms can reference
+an eval-family vector by symbol, and Stage 5 instruction RA / Stage 6 bytecode
+RA products use that path. The Stage 5 instruction read-RAF and Stage 6
+bytecode read-RAF relation plans now reference the same plan-level
+`STAGE*_INDEXED_EVAL_FAMILIES` rows instead of emitting duplicate
+relation-local `NamedEvalFamilyPlan` constants. Output relation rows now name
+their terminal scalar `expected_output`, keeping verifier expected-output data
+separate from input sumcheck `claim_value` data. The Rust planning surface now
+uses `RelationOutputPlan`, `relation_outputs`, and `STAGE*_RELATION_OUTPUTS`
+instead of the old `SumcheckOutputClaimPlan`/`output_claims` names. Output eval
+families are still relation-output scalar machinery rather than first-class
+value rows.
+
+### Dialect changes
+
+Extend `crates/bolt/irdl/compute.mlir` (no new dialect; these are dataflow
+ops, same family as the existing `point_*` and `field_*` ops). Add an explicit
+vector carrier instead of overloading `@compute::@point<>`:
+
+```mlir
+irdl.type @field_vector
+```
+
+Then add typed scalar, point, and vector producers:
+
+```mlir
+compute.poly_mle              %p1, %p2 -> %scalar
+compute.poly_eq_indexed       %point, index = N -> %scalar
+compute.poly_identity_eval    %point -> %scalar
+compute.poly_lt_eval          %x, %y -> %scalar
+compute.poly_operand_eval     %point, side = "left" | "right" -> %scalar
+
+compute.point_reverse         %p -> %p'
+compute.point_split           %p, at = log_k -> %lo, %hi
+compute.point_prefix          %p, length = N -> %p'
+compute.point_suffix          %p, length = N -> %p'
+
+compute.field_pow_vector      %base, count = N -> %vec : !field_vector
+compute.field_vector_product  %vec -> %scalar
+compute.field_vector_sum      %vec -> %scalar
+```
+
+`compute::poly_mle` is the workhorse. The other `poly_*` ops are convenient
+specializations for relations that already exist (`identity`, `lt`,
+`operand`, `eq_indexed`). `field_vector_*` ops exist because verifier math
+uses ordered scalar tuples whose meaning is not a multilinear query point.
+
+### Runtime additions
+
+`bolt-verifier-runtime` may retain typed value storage and interpreters, but
+the planning passes should decide which values exist and how they are connected.
+The runtime should evaluate typed plan rows, not infer semantics from symbol
+names:
+
+```rust
+pub enum VerifierValueKind {
+    Scalar,
+    Point,
+    FieldVector,
+    EvalFamily,
+}
+
+pub enum ScalarExprKind {
+    OpeningEval,
+    Add,
+    Sub,
+    Mul,
+    Neg,
+    Pow(usize),
+    LagrangeBasisEval { domain_start: i64, domain_size: usize, index: usize },
+    PolyMle,
+    PolyEqIndexed { index: usize },
+    PolyIdentityEval,
+    PolyLtEval,
+    PolyOperandEval { side: OperandSide },
+    FieldVectorProduct,
+    FieldVectorSum,
+}
+
+pub enum PointExprKind {
+    Reverse,
+    Prefix { length: usize },
+    Suffix { length: usize },
+    SplitLo { at: usize },
+    SplitHi { at: usize },
+}
+
+pub enum FieldVectorExprKind {
+    Powers { count: usize },
+    EvalFamily,
+}
+```
+
+`ValueStore` should store each value in the correct domain. The scalar
+interpreter should call `jolt-poly` for equality, less-than, identity, Lagrange,
+and projected-bit polynomial helpers. Point transforms must be evaluated by the
+point interpreter and vector producers by the vector interpreter. This keeps the
+type boundary honest and prevents the runtime from becoming a bag of ad hoc
+helper functions.
+
+### Locked conversion order
+
+1. Build the value-graph foundation: scalar, point, field-vector, and
+   eval-family storage and plan rows.
+2. Convert Stage 3 expected-output checks first:
+   Spartan shift, instruction input, and registers claim reduction.
+3. Convert Stage 4 next:
+   registers read-write, RAM val check, `lt` evaluation, suffix points, and
+   the Stage 4 register-read-write point normalization.
+4. Convert the small Stage 5 relations next:
+   RAM RA claim reduction and registers val evaluation.
+5. Convert Stage 2 in two parts:
+   RAM read-write / product remainder / instruction lookup first, then RAM RAF,
+   RAM output, and univariate-skip-specific logic later.
+6. Convert Stage 6/7 family relations after eval-family support:
+   booleanity, hamming booleanity, RAM RA virtual, instruction RA virtual, inc
+   reduction, and Stage 7 hamming-weight reduction.
+7. Defer S5 instruction read-RAF and S6 bytecode read-RAF until lookup-table,
+   bytecode-entry, and external-data domains are designed.
+
+### Deliberate deferrals
+
+Do not start S3 by designing generic bytecode-row algebra, RAM sparse
+evaluators, lookup-table MLE plans, or univariate-skip verifier replacement.
+Those are real verifier facts, but starting there would likely create a too
+general mini-language before the scalar/point/vector graph has been validated
+on simpler relations.
+
+### Blockers and complications
+
+- **`jolt-poly` API stability.** `EqPolynomial::mle` must have a stable
+  signature and bit-exact semantics. `jolt-poly` is on the Bolt side of the
+  generic compiler, so this is fine, but worth a sanity check that we're
+  not pinning to an evolving signature.
+- **Value graph foundation.** If S3 starts feeling like a pile of unrelated
+  enum variants, stop and implement the typed value graph first. A clean
+  scalar/point/vector split is more important than landing every primitive in
+  one PR.
+- **`@compute::@field_vector<>` as MLIR type.** Do not re-use `@point<>` for
+  gamma-power vectors. Points are multilinear query coordinates; gamma powers
+  are ordered scalar tuples. Conflating them would make later relation-plan
+  typing harder and hide meaning from reviewers.
+- **Stage emitter updates.** Stage 3/4 should be the first emitters to lower
+  relation-output math to value-graph rows. Stage 6/7 remain later consumers
+  once eval families and bytecode/external-data boundaries are clear.
+- **Validator updates.** Each new `compute::*` op needs an entry in the
+  Bolt validator so malformed plans (wrong arity, wrong operand types) are
+  rejected at compile time.
+
+### Acceptance criteria
+
+`muldiv` e2e test passes in both `--features host` and `--features host,zk`
+(this is the workspace's primary correctness check). Stage 3 and Stage 4
+expected-output helper bodies are replaced by typed value-graph plan rows. New
+metrics in `verifier_cleanup.rs`: `compute_poly_op_call_sites`,
+`compute_point_op_call_sites`, `value_graph_relation_outputs`, and
+`handwritten_expected_output_functions` reported. Gate only the Stage 3/4
+cutover in this slice; do not claim Stage 6/7 relation math is solved yet.
+
+### Rollback
+
+Each new MLIR op is independently revertible. Worst case we keep the
+`poly_mle` op (which is unambiguous) and revert the `normalize_*_point`
+lowering if the dataflow ordering turns out to be subtle.
+
+### Estimated wall-clock
+
+Two agent sessions, ~120-180 minutes total. Most of the time is in the
+planning/emitter changes for the first Stage 3/4 conversions and validator
+updates.
+
+---
+
+## S4: Typed indexed-eval addressing
+
+**Goal.** Keep eval-family reconstruction out of verifier runtime/Tier B and
+finish moving indexed-eval family facts into typed verifier-plan data.
+
+### Current status
+
+The original Tier B problem has been removed on the current stack. Generated
+Jolt relation code and `bolt-verifier-runtime` no longer call
+`indexed_evals_by_prefix*`, and `verifier_cleanup` now gates both generated
+relation code and the runtime against reintroducing indexed eval-prefix APIs.
+
+Stage 5 instruction read-RAF and Stage 6 bytecode read-RAF now carry explicit
+Bolt-side `IndexedEvalFamilyPlan` rows in the verifier-stage plan. The relevant
+relation-output planners consume those rows instead of re-deriving the
+family from raw evals at the point of Rust token emission.
+
+Stage 5/6 family membership now originates as first-class
+`piop.sumcheck_eval_family`, `compute.sumcheck_eval_family`, and
+`cpu.sumcheck_eval_family` rows. The CPU-to-verifier planning layer parses those
+rows directly; it no longer infers family membership from symbol spelling,
+oracle prefixes, or raw eval ordering.
+
+This is still not the final architecture. The current family op is typed
+planning metadata with explicit `evals` membership, not yet a first-class
+field-vector value in the verifier value graph. S3 should decide how field
+vectors/eval families flow as typed values; S4's job is to make the existing
+Stage 5/6 family facts explicit and non-prefix-derived before Rust token
+emission.
+
+### Dialect changes
+
+Add a sibling no-result eval-family op in the PIOP, compute, and CPU dialects:
+
+```mlir
+compute.sumcheck_eval_family {
+  sym_name = "stage6.bytecode_read_raf.eval.BytecodeRa"
+  source = "stage6.sumcheck"
+  oracle_family = "BytecodeRa"
+  count = 3
+  evals = [@stage6.bytecode_read_raf.eval.BytecodeRa_0,
+           @stage6.bytecode_read_raf.eval.BytecodeRa_1,
+           @stage6.bytecode_read_raf.eval.BytecodeRa_2]
+}
+```
+
+The existing scalar `sumcheck_eval` ops remain the source of the serialized
+named evals. The family row is an explicit membership declaration consumed by
+the verifier-plan layer. A later S3/S5 value-graph slice can promote this shape
+to a typed field-vector value if that makes the Rust emission smaller and
+clearer. On the current stack, the first promotion has landed for Stage 5/6:
+the plan-level indexed eval-family rows are emitted as runtime
+`NamedEvalFamilyPlan` slices, seeded as field-vector values, and reused by the
+relation plans that need the same family contract.
+
+### Runtime additions
+
+No runtime API is added for the metadata-row phase. `bolt-verifier-runtime`
+continues to expose only the boring reusable mechanics, while the Jolt verifier
+plan carries `IndexedEvalFamilyPlan` rows. Runtime `FieldVector`/`ValueStore`
+support belongs in S3 only if the typed verifier value graph needs it.
+
+### Tier B impact
+
+Stage 6/7 relation evaluators should continue to receive typed eval-family
+plans or typed field-vector values, never reconstruct families from prefixes.
+Remaining reductions are expected on the Bolt emitter/planning side, not from
+deleting more Tier B prefix code.
+
+### Blockers and complications
+
+- **Proof format.** The proof's `evals` field is already
+  `Vec<StageNamedEval<F>>` with explicit `name` strings in the extracted
+  `bolt-verifier-runtime` API. S4 changes how the *verifier consumes* named
+  evals, not how they are serialized. No back-compat break. *This was the
+  biggest risk; it is not real.*
+- **Prover/verifier symmetry.** The prover-side emitter must annotate the
+  same eval block as a family. If this is a separate emitter, both must be
+  updated together.
+- **Typed source of truth.** `IndexedEvalFamilyPlan` is now parsed from
+  CPU/MLIR eval-family rows for Stage 5/6. Remaining risk is scope, not
+  ambiguity: Stage 7 and future relation plans need the same rule when they
+  start consuming family-shaped data.
+- **Testing.** Add a `verifier_cleanup` gate
+  `RELATION_INDEXED_EVAL_PREFIX_SITES_CEILING = 0` that fires if any
+  generated stage source still calls `indexed_evals_by_prefix*` or exposes
+  eval-prefix fields. This gate is now present.
+
+### Acceptance criteria
+
+`muldiv` passes in both modes. Zero `indexed_evals_by_prefix*` call sites
+in the generated verifier and runtime. Indexed eval-family membership is
+represented as typed CPU/verifier-plan data before Rust token emission.
+
+### Rollback
+
+Pure refactor. Roll back by reverting the eval-family slice. Do not keep
+`indexed_evals_by_prefix_any` in the runtime as a verifier fallback once the
+typed family path lands; that would leave two execution paths and weaken the
+full-cutover guarantee.
+
+### Estimated wall-clock
+
+One agent session, 60-90 minutes.
+
+---
+
+## S5: Relations as typed plan data
+
+**Goal.** Make the Stage 6/7 relation evaluators (`expected_stage67_*`)
+declarative MLIR-derived plans rather than hand-written Rust functions.
+After S5, the only thing left in Tier B is the bytecode-row encoding
+(addressed by S6).
+
+### The shape
+
+After S3 + S4, every `expected_stage67_*` body is structurally:
+
+```text
+val = Σ_i γ^i · (Π_j eq_mle(P_ij, query_point) · eval_k_ij) + boundary_terms
+```
+
+That is a flat algebraic expression DAG over plan operands. The preferred
+abstraction is not a separate relation-expression language; it is a relation
+metadata record pointing at a scalar value produced by the typed verifier value
+graph introduced in S3/S4:
+
+```rust
+pub struct RelationPlan {
+    pub symbol: &'static str,
+    pub stage: &'static str,
+    pub kind: RelationId,
+    pub query_point: &'static str,
+    pub expected_output: &'static str, // scalar produced by value graph
+}
+```
+
+The runtime gains a generic `evaluate_relation_plan(plan, store) -> Fr` that
+only resolves the typed `expected_output` value and applies relation-level
+diagnostics/error mapping. The algebra itself should already be visible as
+scalar/point/vector plan rows. Introduce a separate `RelationTerm` enum only if
+the value graph cannot express a relation without contortions, and document why
+that second interpreter is worth the extra audit surface.
+
+### Dialect changes
+
+The accepted S5 carrier is `compute.sumcheck_output_claim`, not an
+expected-output-bearing `compute.relation` declaration. `compute.relation`
+remains relation metadata: symbol, kind, domain, rounds, degree, and output
+count. The expected-output scalar is a typed value-graph operand of
+`compute.sumcheck_output_claim`, along with the relation symbol/kind and the
+polynomial eval operands that make the output claim auditable:
+
+```mlir
+%expected = compute.field_expr ... : !compute.field
+compute.sumcheck_output_claim %expected, %eval0, %eval1 {
+  sym_name = "stage6.booleanity.output",
+  stage = "stage6",
+  relation = @stage6.booleanity,
+  count = 2 : i64,
+  polynomial_evals = ["stage6.booleanity.eval0", "stage6.booleanity.eval1"]
+}
+```
+
+The CPU lowering preserves that shape as `cpu.sumcheck_output_claim`. Stage
+emitters lower those rows into generated `RelationOutputPlan` data whose
+`expected_output` field points at the typed scalar produced by the value graph.
+Those rows also carry a closed `JoltVerifierRelationKind` relation ID; the
+serialization symbol remains available for diagnostics and equivalence adapters,
+but relation-output verification no longer treats raw strings as the execution
+contract. The expression feeding `expected_output` must remain ordinary typed
+value-graph data, not hidden inside the emitter.
+
+This keeps relation declarations and relation-output claims separate:
+
+- `compute.relation` declares the relation and its static verifier metadata.
+- `compute.sumcheck_output_claim` binds a concrete output-claim scalar to that
+  relation for a verifier stage.
+- Generated `RelationOutputPlan` rows are the Rust target-plan projection.
+
+### Tier C impact (acknowledged growth)
+
+The relation plans and their supporting scalar/point/vector value rows live in
+the *generated* stage Rust, not in the runtime. Stage 6/7 will grow by an
+estimated ~200 LOC of relation/value tables. This is the explicit trade: Tier B
+shrinks by ~200 LOC and Tier C grows by ~200, but Tier C is declarative data
+(audit-easy) while Tier B is hand-written Rust (audit-hard).
+
+The `GENERATED_VERIFIER_TARGET_LOC` ceiling will need to bump from 6,100 to
+~6,300. That is OK provided the structure of stage files becomes more
+declarative.
+
+### Blockers and complications
+
+- **Expressiveness limit.** The typed value graph must express every algebraic
+  shape that the Stage 6/7 relations currently use. Today's shapes are
+  uniform; future relations may not be. If Bolt acquires a new protocol with
+  relations that have control flow (e.g., conditional structure based on entry
+  data), extend the value graph or add a carefully-scoped relation interpreter
+  rather than escaping into generated helper functions.
+- **Bytecode-read-RAF special case.** The bytecode-read-RAF evaluator has
+  a `for index in 0..stage_value_evals.len()` loop with a per-index
+  `int_contrib` mask. Model the loop as a value-graph reduction over a static
+  row table, but keep the mask values in the bytecode-encoding plan because
+  they are Jolt-specific (S6 territory). For S5, the relation consumes the
+  resulting scalar or vector as an opaque typed value; the relation metadata
+  itself stays generic.
+- **Performance.** The verifier-side value graph walks a small DAG. We expect
+  zero perf concern. Keep a smoke benchmark anyway since this code runs once
+  per Stage 6/7 sumcheck instance.
+- **Audit story.** Tier B drops to ~290 LOC, almost all of which is the
+  bytecode encoder. We should explicitly document in `GOAL.md` that the
+  relation algebra is *no longer* part of the audit surface; only the
+  generic interpreter (in `bolt-verifier-runtime`) and the bytecode
+  encoder are.
+
+### Acceptance criteria
+
+Same correctness gates plus: `expected_stage67_*` functions in Tier B
+are deleted. `compute.sumcheck_output_claim` and any value-graph ops it depends
+on have validator coverage. Generated stages contain typed `RelationOutputPlan`
+rows, and the cleanup gate reports `handwritten_expected_output_functions: 0`.
+`muldiv` passes in both modes, and verifier-time perf evidence is recorded.
+
+### Rollback
+
+This is the most invasive slice. If the relation interpreter design is
+wrong, S5 should be revertible by restoring the deleted
+`expected_stage67_*` functions and removing the `RelationOutputPlan` emitter
+output. Do not keep the old helpers as a fallback in generated verifier code;
+that would violate the full-cutover rule. If comparison material is needed,
+keep it only in the local never-commit worklog while S5 is being shaken down.
+
+### Estimated wall-clock
+
+Three to four agent sessions, ~6 hours of agent runtime in total. Highest
+risk slice in this plan.
+
+---
+
+## S6: Bytecode encoding as typed plan data (optional)
+
+**Goal.** Capture the Jolt-specific bytecode-row encoding rules as a
+typed table rather than hand-written Rust. After S6, Tier B is ~50 LOC
+and is essentially just `Stage67BytecodeEntry` (the data table itself,
+not the math).
+
+### The encoding today
+
+`stage67_bytecode_entry_stage_values` decomposes a bytecode row into 5
+gamma-weighted sums (one per Stage 1-5). The pattern for each stage:
+
+```rust
+let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1];
+for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) {
+    if *flag { stage1 += *gamma; }
+}
+```
+
+This is a small DSL for "for each entry field, conditionally add a
+gamma-weighted contribution." The fields and their conditions vary per
+stage but the *shape* is uniform.
+
+### Capture as data
+
+```rust
+pub struct BytecodeEncodingPlan {
+    pub stage_terms: [&'static [BytecodeTerm]; 5],
+}
+
+pub enum BytecodeTerm {
+    Address                                    { gamma_index: usize },
+    Imm                                        { gamma_index: usize },
+    CircuitFlag       { index: usize,            gamma_index: usize },
+    EntryFlag         { which: BytecodeFlag,     gamma_index: usize },
+    RegisterEq        { which: RegisterRole,     gamma_index: usize },
+    LookupTableIndex  { offset: usize,           gamma_base: usize },
+}
+
+pub enum BytecodeFlag { IsInterleaved, IsBranch, IsNoop, LeftIsRs1, ... }
+pub enum RegisterRole { Rd, Rs1, Rs2 }
+```
+
+The runtime gains `evaluate_bytecode_encoding(entries, plan, gamma_powers,
+register_points) -> [Fr; 5]`. Tier B keeps only the
+`Stage67BytecodeEntry` trait and the per-stage `Stage6BytecodeEntry` /
+`Stage7BytecodeEntry` impls (~50 LOC).
+
+### Dialect changes
+
+Optional: a `bytecode.encoding_plan` op family in a new `bytecode.mlir`
+sub-dialect, OR keep `BytecodeEncodingPlan` purely as runtime-side data
+that the Bolt emitter populates from a small declarative source. Lean:
+declarative source first, dialect later if a second protocol uses the
+same shape.
+
+### Blockers and complications
+
+- **Protocol-specificity.** This encoding is genuinely Jolt-specific. If
+  Bolt only ever has one protocol with this exact shape, S6 is overkill
+  and we should leave Tier B at ~290 LOC of typed Rust.
+- **Lookup-table indexing.** `stage5 += stage5_gamma_powers[2 + table];`
+  is a *variable-index* contribution where the index depends on entry
+  data. The plan vocabulary must support this (`LookupTableIndex` above
+  handles it).
+- **Conditional terms.** `if entry.is_interleaved() { ... }` becomes
+  `BytecodeTerm::EntryFlag { which: IsInterleaved, ... }`. Mechanical.
+- **Audit win is small.** The remaining 290 LOC of bytecode encoding is
+  *already* easy to audit; it is a flat sequence of "if flag then add
+  gamma^k" lines. The audit benefit of S6 is lower than S2-S5.
+
+### Recommendation
+
+**Skip S6 unless** Bolt acquires a second protocol that wants the same
+encoding shape. The 290 LOC of typed bytecode-encoding Rust is acceptable
+audit surface as long as it is well-organized and tested. Mark S6 as
+"optional follow-up; revisit when there is a second user."
+
+### Estimated wall-clock
+
+If pursued: two agent sessions, ~3 hours. Otherwise zero.
+
+---
+
+## Cross-cutting concerns
+
+### Coordination with Markos' equivalence track
+
+Each slice that touches generated stage outputs (S2 boundary cleanup, S2.75,
+S3, S4, S5) will require equivalence-side adapter updates in
+`crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs`. The
+correct workflow is:
+
+1. Land the slice (compiler change + regenerated stage Rust + equivalence
+   adapter update) in one PR.
+2. Stack on top of the most recent Markos tip
+   (`origin/jolt-v2/equivalence` today).
+3. Do not split the slice across two PRs (one for compiler, one for
+   equivalence). The cross-crate type changes are too tightly coupled.
+
+If Markos pushes new commits to `jolt-v2/equivalence` while a slice is in
+flight, the right move is `git rebase origin/jolt-v2/equivalence` and
+re-run the full check matrix, not `git merge`.
+
+### Generic compiler vs Jolt-specific quarantine
+
+GOAL.md's "Locked Genericity Decisions" require that generic Bolt
+compiler infrastructure not contain Jolt-specific code, and that Jolt
+emitters be progressively lifted into generic CPU emitters.
+
+The current stack has corrected the most important protocol-ID boundary by
+moving Jolt relation variants out of `bolt-verifier-runtime`. The next boundary
+work is subtler: do not let the runtime or the Rust emitter become a second
+home for Jolt semantics under generic names. Any branch on relation kind,
+point-order spelling, eval-name prefix, source-stage string, or proof-slot
+string must either become typed planning-pass output or stay visibly
+quarantined in `crates/bolt/src/protocols/jolt/` / `jolt_relations.rs`.
+
+S2.75, S3, and S4 are primarily compute/planning extensions. They should add a
+typed verifier value graph (`Scalar`, `Point`, `FieldVector`, eval families)
+rather than a larger bag of scalar-only field-expression variants or runtime
+string dispatch.
+
+S5 keeps `compute.relation` as generic relation metadata and uses
+`compute.sumcheck_output_claim` to bind a typed expected-output scalar to that
+relation. This is not a Jolt-specific relation language. Closed relation enums
+live at the protocol/stage boundary; the generic runtime is parameterized over
+the protocol relation enum when it needs equality or dispatch. Opaque typed
+symbols are for generic storage paths that do not branch on relation kind.
+
+S6 is explicitly Jolt-specific. If pursued, it goes under
+`crates/bolt/src/protocols/jolt/`, not in `bolt-verifier-runtime`.
+
+### Trust boundary and audit surface evolution
+
+The audit surface contracts as we move through the slices:
+
+```text
+post-S1:  Tier A (1,265 LOC)  + Tier B (638 LOC)  = 1,903 LOC audited
+current:  narrow runtime    + Tier B (<=700 LOC) = runtime reviewed once,
+                                                    Jolt math quarantined
+post-S3:  narrow runtime    + Tier B (~500 LOC)  = value graph absorbs
+                                                    simpler relation math
+post-S4:  narrow runtime    + Tier B (~350 LOC)  = eval-family strings gone
+post-S5:  narrow runtime    + Tier B (~290 LOC)  = relations become plans
+post-S6:  narrow runtime    + Tier B (~50 LOC)   = optional bytecode data
+```
+
+The shape of the audit also changes: post-S5, almost all of Tier B is the
+bytecode encoder, which is *data-table-shaped* hand-written Rust. That is
+qualitatively easier to review than algebraic relation evaluators.
+
+### MLIR dialect growth
+
+`compute.mlir` is currently 808 lines. After S3 + S4 + S5 it will probably
+land around 1,000-1,100 lines with the new poly, point-reordering,
+pow-vector, eval-family, and relation ops. Still small enough to be one
+dialect; no need for a `poly` or `relation` sub-dialect at that point.
+Revisit if `compute.mlir` exceeds ~1,500 lines.
+
+### Performance
+
+Verifier perf is not the center of this track, but it is a non-regression
+contract. The existing ignored `jolt-equivalence/tests/bolt_perf.rs` gates give
+us real-data core-vs-Bolt setup/prove/verify/proof-size/RSS measurements, but
+their current thresholds are broad smoke limits. Treat them as necessary but
+not sufficient for interpreter-heavy slices.
+
+Before closing S2.75/S3/S5 completion, record verifier-time evidence from the
+SHA2-chain perf oracle. For future interpreter-heavy slices, capture a local
+baseline before the slice and rerun after it. If a verifier-time change is
+noisy, rerun before calling it real. If a repeatable regression remains, either
+fix it or explicitly document why the readability/security gain is worth the
+cost. Do not loosen perf thresholds to make a refactor pass. The existing
+S2/S2.5 progress should keep its captured baselines as reference data.
+
+Current evidence from May 16, 2026 on `quang/bolt-stack` is green but close:
+the 2^16 oracle passed with verifier ratio `1.090x` and prove ratio `0.856x`;
+the 2^20 one-sample oracle passed with verifier ratio `1.124x` and prove ratio
+`1.298x` against the `1.300x` prove gate; the 2^20 three-sample oracle passed
+after the Stage 2 verifier-plan cutover with verifier ratio `1.089x` and prove
+mean `1.168x`, 95% CI `[0.876x, 1.460x]`. Treat this as a green completion
+gate with noisy margin, not a reason to loosen thresholds.
+
+The expected trend is "no measurable verifier change," because the interpreter
+dispatches are straightforward and relation/value-graph evaluation happens a
+small fixed number of times per verification. Any accidental
+quadratic-in-trace-length loop is a blocker.
+
+### Compatibility with the `zk` feature
+
+All five slices are `cfg`-independent. They affect plan generation and
+verifier interpretation, both of which are identical between the standard
+and `zk` modes. Each slice must run `muldiv` in both
+`--features host` and `--features host,zk` per the workspace's primary
+correctness check.
+
+### Emitter discipline
+
+The Rust emitter should become a pretty-printer for typed plans, not the place
+where verifier semantics are invented. Use these checks during every slice:
+
+- If the emitter needs to classify a verifier fact, add or extend a planning
+  pass instead.
+- If emitted Rust contains a new helper function with protocol math, ask why
+  that helper is not a typed value-graph op or relation plan row.
+- If the emitter parses or assembles meaning from a symbol string, add a typed
+  MLIR attr or plan field instead.
+- If a runtime API accepts `&'static str` and branches on its contents, replace
+  it with a typed enum, typed symbol, or protocol-supplied ID.
+- If two interpreters can evaluate the same verifier fact, delete one in the
+  same slice.
+- If a generated table is too dense for blind review, improve the table shape
+  before counting the LOC reduction as a win.
+
+---
+
+## Locked sequencing decisions
+
+The investigation pass resolved the implementation choices that should guide the
+next autonomous implementation slices:
+
+1. Keep `bolt-verifier-runtime`, but define it narrowly. It is a verifier
+   interpreter crate, not a generic codegen dumping ground.
+2. Runtime relation-bearing plan structs remain generic over
+   `R: ProtocolRelation`; Jolt relation variants live in `JoltRelationKind`.
+3. Add CPU-to-Rust planning passes before adding more runtime helper surface.
+4. Stage 8 source-stage handling is local to Stage 8 until the PCS/opening
+   model is made fully typed.
+5. Legacy names such as `ThroughStage5` may remain as user-facing constructors,
+   but internally they resolve to `VerifierTarget { checkpoint, evaluation }`.
+6. S2.75, S3, and S5 need before/after verifier-time baselines because they add
+   or change interpreter/planning execution.
+7. S3 starts with the value-graph foundation plus Stage 3/4 conversions. It
+   does not start with bytecode, RAM sparse evaluators, lookup-table MLEs, or
+   univariate-skip verifier replacement.
+8. S6 remains optional and should be deferred unless there is a second protocol
+   user or concrete audit pressure for typed bytecode-row encoding.
+
+---
+
+## Sequencing decision tree
+
+```text
+Current stack.                                   [already in progress]
+  Runtime extraction, typed relation IDs, top-level verifier program,
+  relation-output plans, cleanup gates.
+
+Do S2 boundary audit next.                        [unconditional]
+  Narrow runtime APIs.
+  Move polynomial helpers to jolt-poly.
+  Classify runtime vs Jolt verifier core vs planning-pass ownership.
+
+Add S2.75 planning seams next.                    [unconditional]
+  Make CPU-to-Rust verifier planning explicit.
+  Prevent new semantics from landing in emitters or runtime string dispatch.
+
+Audit S3/S4/S5 completion.                        [unconditional]
+  Confirm scalar/point/field-vector/eval-family value graph coverage.
+  Keep `compute.sumcheck_output_claim` as the expected-output carrier and
+  `compute.relation` as static relation metadata.
+  Verify old eval-prefix reconstruction and `expected_stage67_*` helpers stay
+  deleted.
+
+Capture verifier perf evidence.                  [unconditional]
+  Run the SHA2-chain core-vs-Bolt perf oracle and record verifier-time results
+  before closing the goal.
+
+S6 only on demand.                               [optional]
+  Defer until there is a concrete second user or audit pressure.
+```
+
+---
+
+This plan is the agent-side complement to GOAL.md's `Concrete Gates` and
+`Iteration Algorithm`. Update both files together when a slice lands so
+the goal definition and the implementation plan stay in sync.
diff --git a/crates/bolt/irdl/compute.mlir b/crates/bolt/irdl/compute.mlir
index 60c01c9eaa..4f4c8aeace 100644
--- a/crates/bolt/irdl/compute.mlir
+++ b/crates/bolt/irdl/compute.mlir
@@ -640,6 +640,20 @@ irdl.dialect @compute {
     irdl.operands(result: %result)
     irdl.results(eval: %eval)
   }
+  irdl.operation @sumcheck_eval_family {
+    %sym = irdl.any
+    %source = irdl.any
+    %oracle_family = irdl.any
+    %count = irdl.any
+    %evals = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "source" = %source,
+      "oracle_family" = %oracle_family,
+      "count" = %count,
+      "evals" = %evals
+    }
+  }
   irdl.operation @sumcheck_instance_result {
     %input_point = irdl.parametric @compute::@point<>
     %output_point = irdl.parametric @compute::@point<>
@@ -670,6 +684,111 @@ irdl.dialect @compute {
     irdl.operands(input_point: %input_point, input_result: %input_result)
     irdl.results(instance_point: %output_point, instance_result: %output_result)
   }
+  irdl.operation @structured_polynomial_eval {
+    %point = irdl.parametric @compute::@point<>
+    %value = irdl.parametric @compute::@field_value<>
+    %sym = irdl.any
+    %polynomial = irdl.any
+    %x_point_segment = irdl.any
+    %x_point_length = irdl.any
+    %x_point_order = irdl.any
+    %y_point_segment = irdl.any
+    %y_point_length = irdl.any
+    %y_point_order = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "polynomial" = %polynomial,
+      "x_point_segment" = %x_point_segment,
+      "x_point_length" = %x_point_length,
+      "x_point_order" = %x_point_order,
+      "y_point_segment" = %y_point_segment,
+      "y_point_length" = %y_point_length,
+      "y_point_order" = %y_point_order
+    }
+    irdl.operands(x_point: %point, y_point: %point)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_eval_family {
+    %value = irdl.parametric @compute::@field_value<>
+    %sym = irdl.any
+    %power_stride = irdl.any
+    %value_term_offsets = irdl.any
+    %shared_term_offsets = irdl.any
+    %item_term_offsets = irdl.any
+    %evals = irdl.any
+    %shared_terms = irdl.any
+    %item_terms = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "power_stride" = %power_stride,
+      "value_term_offsets" = %value_term_offsets,
+      "shared_term_offsets" = %shared_term_offsets,
+      "item_term_offsets" = %item_term_offsets,
+      "evals" = %evals,
+      "shared_terms" = %shared_terms,
+      "item_terms" = %item_terms
+    }
+    irdl.operands(gamma: %value, inputs: variadic %value)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_product_family {
+    %value = irdl.parametric @compute::@field_value<>
+    %sym = irdl.any
+    %gamma = irdl.any
+    %term_gamma_power_offsets = irdl.any
+    %term_eval_counts = irdl.any
+    %term_factor_counts = irdl.any
+    %evals = irdl.any
+    %factors = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "gamma" = %gamma,
+      "term_gamma_power_offsets" = %term_gamma_power_offsets,
+      "term_eval_counts" = %term_eval_counts,
+      "term_factor_counts" = %term_factor_counts,
+      "evals" = %evals,
+      "factors" = %factors
+    }
+    irdl.operands(inputs: variadic %value)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_function_family {
+    %value = irdl.parametric @compute::@field_value<>
+    %sym = irdl.any
+    %gamma = irdl.any
+    %term_gamma_power_offsets = irdl.any
+    %term_functions = irdl.any
+    %term_factor_counts = irdl.any
+    %evals = irdl.any
+    %factors = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "gamma" = %gamma,
+      "term_gamma_power_offsets" = %term_gamma_power_offsets,
+      "term_functions" = %term_functions,
+      "term_factor_counts" = %term_factor_counts,
+      "evals" = %evals,
+      "factors" = %factors
+    }
+    irdl.operands(inputs: variadic %value)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_claim {
+    %value = irdl.parametric @compute::@field_value<>
+    %sym = irdl.any
+    %stage = irdl.any
+    %relation = irdl.any
+    %count = irdl.any
+    %polynomial_evals = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "stage" = %stage,
+      "relation" = %relation,
+      "count" = %count,
+      "polynomial_evals" = %polynomial_evals
+    }
+    irdl.operands(claim_value: %value, polynomial_evals: variadic %value)
+  }
   irdl.operation @opening_claim {
     %point = irdl.parametric @compute::@point<>
     %eval = irdl.parametric @compute::@field_value<>
diff --git a/crates/bolt/irdl/cpu.mlir b/crates/bolt/irdl/cpu.mlir
index 22fe7ad519..8d10422534 100644
--- a/crates/bolt/irdl/cpu.mlir
+++ b/crates/bolt/irdl/cpu.mlir
@@ -570,6 +570,20 @@ irdl.dialect @cpu {
     irdl.operands(result: %result)
     irdl.results(eval: %eval)
   }
+  irdl.operation @sumcheck_eval_family {
+    %sym = irdl.any
+    %source = irdl.any
+    %oracle_family = irdl.any
+    %count = irdl.any
+    %evals = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "source" = %source,
+      "oracle_family" = %oracle_family,
+      "count" = %count,
+      "evals" = %evals
+    }
+  }
   irdl.operation @sumcheck_instance_result {
     %input_point = irdl.parametric @cpu::@point<>
     %output_point = irdl.parametric @cpu::@point<>
@@ -600,6 +614,111 @@ irdl.dialect @cpu {
     irdl.operands(input_point: %input_point, input_result: %input_result)
     irdl.results(instance_point: %output_point, instance_result: %output_result)
   }
+  irdl.operation @structured_polynomial_eval {
+    %point = irdl.parametric @cpu::@point<>
+    %value = irdl.parametric @cpu::@field_value<>
+    %sym = irdl.any
+    %polynomial = irdl.any
+    %x_point_segment = irdl.any
+    %x_point_length = irdl.any
+    %x_point_order = irdl.any
+    %y_point_segment = irdl.any
+    %y_point_length = irdl.any
+    %y_point_order = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "polynomial" = %polynomial,
+      "x_point_segment" = %x_point_segment,
+      "x_point_length" = %x_point_length,
+      "x_point_order" = %x_point_order,
+      "y_point_segment" = %y_point_segment,
+      "y_point_length" = %y_point_length,
+      "y_point_order" = %y_point_order
+    }
+    irdl.operands(x_point: %point, y_point: %point)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_eval_family {
+    %value = irdl.parametric @cpu::@field_value<>
+    %sym = irdl.any
+    %power_stride = irdl.any
+    %value_term_offsets = irdl.any
+    %shared_term_offsets = irdl.any
+    %item_term_offsets = irdl.any
+    %evals = irdl.any
+    %shared_terms = irdl.any
+    %item_terms = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "power_stride" = %power_stride,
+      "value_term_offsets" = %value_term_offsets,
+      "shared_term_offsets" = %shared_term_offsets,
+      "item_term_offsets" = %item_term_offsets,
+      "evals" = %evals,
+      "shared_terms" = %shared_terms,
+      "item_terms" = %item_terms
+    }
+    irdl.operands(gamma: %value, inputs: variadic %value)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_product_family {
+    %value = irdl.parametric @cpu::@field_value<>
+    %sym = irdl.any
+    %gamma = irdl.any
+    %term_gamma_power_offsets = irdl.any
+    %term_eval_counts = irdl.any
+    %term_factor_counts = irdl.any
+    %evals = irdl.any
+    %factors = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "gamma" = %gamma,
+      "term_gamma_power_offsets" = %term_gamma_power_offsets,
+      "term_eval_counts" = %term_eval_counts,
+      "term_factor_counts" = %term_factor_counts,
+      "evals" = %evals,
+      "factors" = %factors
+    }
+    irdl.operands(inputs: variadic %value)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_function_family {
+    %value = irdl.parametric @cpu::@field_value<>
+    %sym = irdl.any
+    %gamma = irdl.any
+    %term_gamma_power_offsets = irdl.any
+    %term_functions = irdl.any
+    %term_factor_counts = irdl.any
+    %evals = irdl.any
+    %factors = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "gamma" = %gamma,
+      "term_gamma_power_offsets" = %term_gamma_power_offsets,
+      "term_functions" = %term_functions,
+      "term_factor_counts" = %term_factor_counts,
+      "evals" = %evals,
+      "factors" = %factors
+    }
+    irdl.operands(inputs: variadic %value)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_claim {
+    %value = irdl.parametric @cpu::@field_value<>
+    %sym = irdl.any
+    %stage = irdl.any
+    %relation = irdl.any
+    %count = irdl.any
+    %polynomial_evals = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "stage" = %stage,
+      "relation" = %relation,
+      "count" = %count,
+      "polynomial_evals" = %polynomial_evals
+    }
+    irdl.operands(claim_value: %value, polynomial_evals: variadic %value)
+  }
   irdl.operation @opening_claim {
     %point = irdl.parametric @cpu::@point<>
     %eval = irdl.parametric @cpu::@field_value<>
diff --git a/crates/bolt/irdl/piop.mlir b/crates/bolt/irdl/piop.mlir
index 169bc5c9ab..f1cd50bfcf 100644
--- a/crates/bolt/irdl/piop.mlir
+++ b/crates/bolt/irdl/piop.mlir
@@ -188,6 +188,20 @@ irdl.dialect @piop {
     irdl.operands(result: %result)
     irdl.results(eval: %eval)
   }
+  irdl.operation @sumcheck_eval_family {
+    %sym = irdl.any
+    %source = irdl.any
+    %oracle_family = irdl.any
+    %count = irdl.any
+    %evals = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "source" = %source,
+      "oracle_family" = %oracle_family,
+      "count" = %count,
+      "evals" = %evals
+    }
+  }
   irdl.operation @sumcheck_instance_result {
     %input_point = irdl.parametric @poly::@point<>
     %output_point = irdl.parametric @poly::@point<>
@@ -218,6 +232,111 @@ irdl.dialect @piop {
     irdl.operands(input_point: %input_point, input_result: %input_result)
     irdl.results(instance_point: %output_point, instance_result: %output_result)
   }
+  irdl.operation @structured_polynomial_eval {
+    %point = irdl.parametric @poly::@point<>
+    %value = irdl.parametric @field::@scalar<>
+    %sym = irdl.any
+    %polynomial = irdl.any
+    %x_point_segment = irdl.any
+    %x_point_length = irdl.any
+    %x_point_order = irdl.any
+    %y_point_segment = irdl.any
+    %y_point_length = irdl.any
+    %y_point_order = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "polynomial" = %polynomial,
+      "x_point_segment" = %x_point_segment,
+      "x_point_length" = %x_point_length,
+      "x_point_order" = %x_point_order,
+      "y_point_segment" = %y_point_segment,
+      "y_point_length" = %y_point_length,
+      "y_point_order" = %y_point_order
+    }
+    irdl.operands(x_point: %point, y_point: %point)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_eval_family {
+    %value = irdl.parametric @field::@scalar<>
+    %sym = irdl.any
+    %power_stride = irdl.any
+    %value_term_offsets = irdl.any
+    %shared_term_offsets = irdl.any
+    %item_term_offsets = irdl.any
+    %evals = irdl.any
+    %shared_terms = irdl.any
+    %item_terms = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "power_stride" = %power_stride,
+      "value_term_offsets" = %value_term_offsets,
+      "shared_term_offsets" = %shared_term_offsets,
+      "item_term_offsets" = %item_term_offsets,
+      "evals" = %evals,
+      "shared_terms" = %shared_terms,
+      "item_terms" = %item_terms
+    }
+    irdl.operands(gamma: %value, inputs: variadic %value)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_product_family {
+    %value = irdl.parametric @field::@scalar<>
+    %sym = irdl.any
+    %gamma = irdl.any
+    %term_gamma_power_offsets = irdl.any
+    %term_eval_counts = irdl.any
+    %term_factor_counts = irdl.any
+    %evals = irdl.any
+    %factors = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "gamma" = %gamma,
+      "term_gamma_power_offsets" = %term_gamma_power_offsets,
+      "term_eval_counts" = %term_eval_counts,
+      "term_factor_counts" = %term_factor_counts,
+      "evals" = %evals,
+      "factors" = %factors
+    }
+    irdl.operands(inputs: variadic %value)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_function_family {
+    %value = irdl.parametric @field::@scalar<>
+    %sym = irdl.any
+    %gamma = irdl.any
+    %term_gamma_power_offsets = irdl.any
+    %term_functions = irdl.any
+    %term_factor_counts = irdl.any
+    %evals = irdl.any
+    %factors = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "gamma" = %gamma,
+      "term_gamma_power_offsets" = %term_gamma_power_offsets,
+      "term_functions" = %term_functions,
+      "term_factor_counts" = %term_factor_counts,
+      "evals" = %evals,
+      "factors" = %factors
+    }
+    irdl.operands(inputs: variadic %value)
+    irdl.results(value: %value)
+  }
+  irdl.operation @sumcheck_output_claim {
+    %value = irdl.parametric @field::@scalar<>
+    %sym = irdl.any
+    %stage = irdl.any
+    %relation = irdl.any
+    %count = irdl.any
+    %polynomial_evals = irdl.any
+    irdl.attributes {
+      "sym_name" = %sym,
+      "stage" = %stage,
+      "relation" = %relation,
+      "count" = %count,
+      "polynomial_evals" = %polynomial_evals
+    }
+    irdl.operands(claim_value: %value, polynomial_evals: variadic %value)
+  }
   irdl.operation @opening_claim {
     %point = irdl.parametric @poly::@point<>
     %eval = irdl.parametric @field::@scalar<>
diff --git a/crates/bolt/src/emit/rust/artifacts.rs b/crates/bolt/src/emit/rust/artifacts.rs
index 1b9936fa77..857aa2bbfc 100644
--- a/crates/bolt/src/emit/rust/artifacts.rs
+++ b/crates/bolt/src/emit/rust/artifacts.rs
@@ -132,6 +132,7 @@ pub struct ProtocolVerifierApiExtension {
     pub error_conversions: String,
     pub after_default_verify: String,
     pub with_programs_body_intro: String,
+    pub verification_body_override: String,
     pub stage_verification_override: String,
     pub after_stage_verification: String,
     pub helper_items: String,
@@ -847,51 +848,58 @@ fn generated_verifier_api(
     if let Some(extension) = extension {
         source.push_str(&extension.verifier.with_programs_body_intro);
     }
-    if let Some(prefix) = &config.instrumentation_prefix {
-        source.push_str(&format!(
-            "    let _verify_span = tracing::info_span!(\"{prefix}.verify\").entered();\n"
-        ));
-    }
-    if let Some(commitment) = &commitment {
-        let verifier_fn = commitment
-            .with_program_verifier_fn
-            .as_deref()
-            .or(commitment.verifier_fn.as_deref())
-            .unwrap_or("missing_commitment_verifier_function");
-        let program_arg = if commitment.with_program_verifier_fn.is_some()
-            && commitment.program_type.is_some()
-            && commitment.program_const.is_some()
-        {
-            format!("programs.{}, ", commitment.field_name)
-        } else {
-            String::new()
-        };
-        source.push_str(&format!(
-            "    let {field} = {module}::{verifier_fn}({program_arg}&proof.commitments, transcript)?;\n",
-            field = commitment.field_name,
-            module = commitment.module_alias,
-        ));
-    }
-    if let Some(extension) = extension {
-        if !extension.verifier.stage_verification_override.is_empty() {
-            source.push_str(&extension.verifier.stage_verification_override);
+    let verification_body_override = extension
+        .map(|extension| extension.verifier.verification_body_override.as_str())
+        .unwrap_or_default();
+    if !verification_body_override.is_empty() {
+        source.push_str(verification_body_override);
+    } else {
+        if let Some(prefix) = &config.instrumentation_prefix {
+            source.push_str(&format!(
+                "    let _verify_span = tracing::info_span!(\"{prefix}.verify\").entered();\n"
+            ));
+        }
+        if let Some(commitment) = &commitment {
+            let verifier_fn = commitment
+                .with_program_verifier_fn
+                .as_deref()
+                .or(commitment.verifier_fn.as_deref())
+                .unwrap_or("missing_commitment_verifier_function");
+            let program_arg = if commitment.with_program_verifier_fn.is_some()
+                && commitment.program_type.is_some()
+                && commitment.program_const.is_some()
+            {
+                format!("programs.{}, ", commitment.field_name)
+            } else {
+                String::new()
+            };
+            source.push_str(&format!(
+                "    let {field} = {module}::{verifier_fn}({program_arg}&proof.commitments, transcript)?;\n",
+                field = commitment.field_name,
+                module = commitment.module_alias,
+            ));
+        }
+        if let Some(extension) = extension {
+            if !extension.verifier.stage_verification_override.is_empty() {
+                source.push_str(&extension.verifier.stage_verification_override);
+            } else {
+                emit_verifier_stage_calls(&mut source, &stages);
+            }
         } else {
             emit_verifier_stage_calls(&mut source, &stages);
         }
-    } else {
-        emit_verifier_stage_calls(&mut source, &stages);
-    }
-    if let Some(extension) = extension {
-        source.push_str(&extension.verifier.after_stage_verification);
-    }
-    source.push_str(&format!("\n    Ok({verification_artifacts_type} {{\n"));
-    if let Some(commitment) = &commitment {
-        source.push_str(&format!("        {},\n", commitment.field_name));
-    }
-    for stage in &stages {
-        source.push_str(&format!("        {},\n", stage.field_name));
+        if let Some(extension) = extension {
+            source.push_str(&extension.verifier.after_stage_verification);
+        }
+        source.push_str(&format!("\n    Ok({verification_artifacts_type} {{\n"));
+        if let Some(commitment) = &commitment {
+            source.push_str(&format!("        {},\n", commitment.field_name));
+        }
+        for stage in &stages {
+            source.push_str(&format!("        {},\n", stage.field_name));
+        }
+        source.push_str("    })\n}\n\n");
     }
-    source.push_str("    })\n}\n\n");
 
     if let Some(extension) = extension {
         source.push_str(&extension.verifier.helper_items);
diff --git a/crates/bolt/src/protocols/jolt/artifacts.rs b/crates/bolt/src/protocols/jolt/artifacts.rs
index 723d0e0ab9..7c12604c48 100644
--- a/crates/bolt/src/protocols/jolt/artifacts.rs
+++ b/crates/bolt/src/protocols/jolt/artifacts.rs
@@ -221,10 +221,10 @@ pub fn jolt_artifact_config() -> ProtocolArtifactConfig {
             "rayon".to_owned(),
         ],
         verifier_dependencies: vec![
+            "bolt-verifier-runtime".to_owned(),
             "jolt-dory".to_owned(),
             "jolt-lookup-tables".to_owned(),
             "jolt-sumcheck".to_owned(),
-            "serde".to_owned(),
         ],
         instrumentation_prefix: Some("bolt".to_owned()),
         prover_forbidden_imports: PROVER_FORBIDDEN_IMPORTS
@@ -242,18 +242,24 @@ pub fn jolt_artifact_config() -> ProtocolArtifactConfig {
         commitment_type: RustTypeRef::new("jolt_dory::DoryCommitment"),
         prover_setup_type: RustTypeRef::new("jolt_dory::DoryProverSetup"),
         role_api_extension: Some(jolt_evaluation_role_api_extension()),
-        verifier_runtime_modules: vec![ProtocolRuntimeModule {
-            module_name: "common".to_owned(),
-            file: GeneratedFile {
-                path: "src/stages/common.rs".to_owned(),
-                source: include_str!("verifier_common.rs.template").to_owned(),
+        verifier_runtime_modules: vec![
+            // Tier B: audited Jolt verifier core (hand-written Stage 6/7
+            // relation evaluators, point normalizations, and Jolt-specific
+            // field-math helpers). NOT generated. See crates/bolt/GOAL.md
+            // "Audit Tiers".
+            ProtocolRuntimeModule {
+                module_name: "jolt_relations".to_owned(),
+                file: GeneratedFile {
+                    path: "src/stages/jolt_relations.rs".to_owned(),
+                    source: include_str!("verifier_jolt_relations.rs.template").to_owned(),
+                },
             },
-        }],
-        verifier_named_eval_type: RustTypeRef::new("crate::stages::common::StageNamedEval"),
+        ],
+        verifier_named_eval_type: RustTypeRef::new("bolt_verifier_runtime::StageNamedEval"),
         verifier_sumcheck_output_type: RustTypeRef::new(
-            "crate::stages::common::StageSumcheckOutput",
+            "bolt_verifier_runtime::StageSumcheckOutput",
         ),
-        verifier_stage_proof_type: RustTypeRef::new("crate::stages::common::StageProof"),
+        verifier_stage_proof_type: RustTypeRef::new("bolt_verifier_runtime::StageProof"),
     }
 }
 
@@ -320,12 +326,16 @@ pub use verifier::{
     verify_jolt_prefix_with_programs, verify_jolt_through_stage5,
     verify_jolt_through_stage5_with_programs, verify_jolt_through_stage6,
     verify_jolt_through_stage6_with_programs, verify_jolt_through_stage7,
-    verify_jolt_through_stage7_with_programs, verify_jolt_with_programs, JoltEvaluationProof,
-    JoltEvaluationProofError, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData,
-    JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData,
-    JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts,
-    JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, JoltVerificationArtifacts,
-    JoltVerifierInputs, JoltVerifierPrograms, JoltVerifierTarget, JoltVerifyError,
+    verify_jolt_through_stage7_with_programs, verify_jolt_with_programs, JoltEvaluationPolicy,
+    JoltEvaluationProof, JoltEvaluationProofError, JoltNamedEval, JoltProof, JoltProofSlot,
+    JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry,
+    JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector,
+    JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput,
+    JoltVerificationArtifacts, JoltVerifierCheckpoint, JoltVerifierInputs,
+    JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepKind,
+    JoltVerifierStepPlan, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError,
+    JOLT_TARGET_FULL, JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6,
+    JOLT_TARGET_THROUGH_STAGE7, JOLT_VERIFIER_STEPS, JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM,
 };"
     .to_owned()
 }
@@ -337,7 +347,7 @@ fn jolt_evaluation_role_api_extension() -> ProtocolArtifactExtension {
         required_artifact_stages: vec!["stage8".to_owned()],
         prover: ProtocolProverApiExtension {
             lib_module: jolt_prover_lib_module(),
-            imports: "#![expect(\n    clippy::too_many_arguments,\n    reason = \"generated prover helpers mirror staged protocol ABIs\"\n)]\n\nuse jolt_dory::{DoryCommitment, DoryHint, DoryProverSetup, DoryScheme};\nuse jolt_field::Fr;\nuse jolt_kernels::{stage1, stage2, stage3, stage4, stage5, stage6, stage7};\nuse jolt_openings::CommitmentScheme;\nuse jolt_poly::{EqPolynomial, Polynomial};\nuse jolt_transcript::{AppendToTranscript, Blake2bTranscript, LabelWithCount, Transcript};\nuse jolt_verifier::{JoltEvaluationProof, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput};\nuse jolt_witness::{stage4_ram_val_init_opening, CycleInput, Stage45SparseTraceWitness, Stage6BytecodeEntry as WitnessStage6BytecodeEntry, Stage6WitnessParams, Stage6WitnessPolynomials, Stage6WitnessSlices};\nuse rayon::prelude::*;\n\n".to_owned(),
+            imports: "#![expect(\n    clippy::too_many_arguments,\n    reason = \"generated prover helpers mirror staged protocol ABIs\"\n)]\n\nuse jolt_dory::{DoryCommitment, DoryHint, DoryProverSetup, DoryScheme};\nuse jolt_field::Fr;\nuse jolt_kernels::{stage1, stage2, stage3, stage4, stage5, stage6, stage7};\nuse jolt_openings::CommitmentScheme;\nuse jolt_poly::{EqPolynomial, Polynomial};\nuse jolt_transcript::{Blake2bTranscript, Transcript};\nuse jolt_verifier::{JoltEvaluationProof, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput};\nuse jolt_witness::{stage4_ram_val_init_opening, CycleInput, Stage45SparseTraceWitness, Stage6BytecodeEntry as WitnessStage6BytecodeEntry, Stage6WitnessParams, Stage6WitnessPolynomials, Stage6WitnessSlices};\nuse rayon::prelude::*;\n\n".to_owned(),
             input_fields:
                 "    pub stage7_openings: Option<&'a [stage7::Stage7OpeningInputValue<Fr>]>,\n"
                     .to_owned(),
@@ -357,23 +367,25 @@ fn jolt_evaluation_role_api_extension() -> ProtocolArtifactExtension {
         },
         verifier: ProtocolVerifierApiExtension {
             lib_module: jolt_verifier_lib_module(),
-            imports: "use std::collections::BTreeMap;\n\nuse jolt_dory::{DoryCommitment, DoryProof, DoryScheme, DoryVerifierSetup};\nuse jolt_field::Fr;\nuse jolt_openings::{AdditivelyHomomorphic, CommitmentScheme, OpeningsError};\nuse jolt_poly::EqPolynomial;\nuse jolt_transcript::{AppendToTranscript, LabelWithCount, Transcript};\n".to_owned(),
+            imports: "use std::collections::BTreeMap;\n\nuse jolt_dory::{DoryCommitment, DoryProof, DoryScheme, DoryVerifierSetup};\nuse jolt_field::Fr;\nuse jolt_openings::{AdditivelyHomomorphic, CommitmentScheme, OpeningsError};\nuse jolt_poly::EqPolynomial;\nuse jolt_transcript::Transcript;\n".to_owned(),
             proof_fields: "    pub evaluation: Option<JoltEvaluationProof>,\n".to_owned(),
-            proof_items: "pub type JoltStage2RamAccess = crate::stages::stage2::Stage2RamAccess;\npub type JoltStage2RamOutputLayout = crate::stages::stage2::Stage2RamOutputLayout;\npub type JoltStage2RamData<'a> = crate::stages::stage2::Stage2RamData<'a>;\npub type JoltStageChallengeVector = crate::stages::common::StageChallengeVector<Fr>;\npub type JoltStageExecutionArtifacts = crate::stages::common::StageExecutionArtifacts<Fr>;\npub type JoltStageOpeningInputValue = crate::stages::common::StageOpeningInputValue<Fr>;\n\n#[derive(Clone, Debug)]\npub struct JoltEvaluationProof {\n    pub joint_opening_proof: DoryProof,\n}\n\n".to_owned(),
+            proof_items: "pub type JoltStage2RamAccess = crate::stages::stage2::Stage2RamAccess;\npub type JoltStage2RamOutputLayout = crate::stages::stage2::Stage2RamOutputLayout;\npub type JoltStage2RamData<'a> = crate::stages::stage2::Stage2RamData<'a>;\npub type JoltStageChallengeVector = bolt_verifier_runtime::StageChallengeVector<Fr>;\npub type JoltStageExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts<Fr>;\npub type JoltStageOpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue<Fr>;\n\n#[derive(Clone, Debug)]\npub struct JoltEvaluationProof {\n    pub joint_opening_proof: DoryProof,\n}\n\n".to_owned(),
             inputs_derive: Some("#[derive(Clone, Copy)]".to_owned()),
             input_fields: "    pub evaluation_setup: Option<&'a DoryVerifierSetup>,\n".to_owned(),
             program_fields:
-                "    pub stage8: &'static stage8_stage::Stage8EvaluationProgramPlan,\n".to_owned(),
-            default_program_fields: "        stage8: &stage8_stage::STAGE8_PROGRAM,\n".to_owned(),
-            error_variants: "    Evaluation(JoltEvaluationProofError),\n".to_owned(),
-            error_items: format!("{}{}", jolt_verifier_target_items(), "#[derive(Debug)]\npub enum JoltEvaluationProofError {\n    MissingProof,\n    MissingVerifierSetup,\n    MissingStageEval { stage: &'static str, eval: &'static str },\n    MissingStage7RaEval,\n    MissingStage7EvaluationPoint,\n    MissingCommitment { oracle: &'static str },\n    InvalidPointLength {\n        artifact: &'static str,\n        expected: usize,\n        actual: usize,\n    },\n    Opening(OpeningsError),\n}\n\n"),
-            error_conversions: "impl From<JoltEvaluationProofError> for JoltVerifyError {\n    fn from(error: JoltEvaluationProofError) -> Self {\n        Self::Evaluation(error)\n    }\n}\n\nimpl From<OpeningsError> for JoltEvaluationProofError {\n    fn from(error: OpeningsError) -> Self {\n        Self::Opening(error)\n    }\n}\n\n".to_owned(),
+                "    pub verifier: &'static JoltVerifierProgramPlan,\n    pub stage8: &'static stage8_stage::Stage8EvaluationProgramPlan,\n".to_owned(),
+            default_program_fields: "        verifier: &VERIFIER_PROGRAM,\n        stage8: &stage8_stage::STAGE8_PROGRAM,\n".to_owned(),
+            error_variants: "    Program(JoltVerifierProgramError),\n    Evaluation(JoltEvaluationProofError),\n".to_owned(),
+            error_items: format!("{}{}", jolt_verifier_program_items(), "#[derive(Debug)]\npub enum JoltEvaluationProofError {\n    MissingProof,\n    MissingVerifierSetup,\n    MissingStageEval { stage: &'static str, eval: &'static str },\n    MissingStage7RaEval,\n    MissingStage7EvaluationPoint,\n    MissingCommitment { oracle: &'static str },\n    InvalidPointLength {\n        artifact: &'static str,\n        expected: usize,\n        actual: usize,\n    },\n    Opening(OpeningsError),\n}\n\n"),
+            error_conversions: "impl From<JoltVerifierProgramError> for JoltVerifyError {\n    fn from(error: JoltVerifierProgramError) -> Self {\n        Self::Program(error)\n    }\n}\n\nimpl From<JoltEvaluationProofError> for JoltVerifyError {\n    fn from(error: JoltEvaluationProofError) -> Self {\n        Self::Evaluation(error)\n    }\n}\n\nimpl From<OpeningsError> for JoltEvaluationProofError {\n    fn from(error: OpeningsError) -> Self {\n        Self::Opening(error)\n    }\n}\n\n".to_owned(),
             after_default_verify: "pub fn verify_jolt_prefix<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_prefix_with_programs(proof, inputs, default_verifier_programs(), transcript) }\n\npub fn verify_jolt_through_stage5<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_through_stage5_with_programs(proof, inputs, default_verifier_programs(), transcript) }\n\npub fn verify_jolt_through_stage6<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_through_stage6_with_programs(proof, inputs, default_verifier_programs(), transcript) }\n\npub fn verify_jolt_through_stage7<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_through_stage7_with_programs(proof, inputs, default_verifier_programs(), transcript) }\n\n".to_owned(),
-            with_programs_body_intro: "    verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::Full)\n}\n\npub fn verify_jolt_through_stage5_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage5) }\n\npub fn verify_jolt_through_stage6_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage6) }\n\npub fn verify_jolt_through_stage7_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage7) }\n\npub fn verify_jolt_prefix_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_through_stage7_with_programs(proof, inputs, programs, transcript) }\n\nfn verify_jolt_with_programs_inner<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T, target: JoltVerifierTarget) -> Result<JoltVerificationArtifacts, JoltVerifyError> {\n".to_owned(),
-            stage_verification_override: jolt_verifier_stage_verification(),
-            after_stage_verification: jolt_verifier_evaluation_check(),
+            with_programs_body_intro: "    verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_FULL)\n}\n\npub fn verify_jolt_through_stage5_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE5) }\n\npub fn verify_jolt_through_stage6_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE6) }\n\npub fn verify_jolt_through_stage7_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE7) }\n\npub fn verify_jolt_prefix_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_through_stage7_with_programs(proof, inputs, programs, transcript) }\n\nfn verify_jolt_with_programs_inner<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T, target: JoltVerifierTarget) -> Result<JoltVerificationArtifacts, JoltVerifyError> {\n".to_owned(),
+            verification_body_override: jolt_verifier_execution_body(),
+            stage_verification_override: String::new(),
+            after_stage_verification: String::new(),
             helper_items: format!(
-                "{}{}",
+                "{}{}{}",
+                jolt_verifier_program_executor(),
                 jolt_verifier_input_helpers("Jolt"),
                 jolt_verifier_evaluation_helpers("Jolt", "Fr")
             ),
@@ -381,16 +393,338 @@ fn jolt_evaluation_role_api_extension() -> ProtocolArtifactExtension {
     }
 }
 
-fn jolt_verifier_target_items() -> String {
-    "#[derive(Clone, Copy, Debug, PartialEq, Eq)]\npub enum JoltVerifierTarget {\n    ThroughStage5,\n    ThroughStage6,\n    ThroughStage7,\n    Full,\n}\n\nimpl JoltVerifierTarget {\n    fn verifies_stage6(self) -> bool { matches!(self, Self::ThroughStage6 | Self::ThroughStage7 | Self::Full) }\n    fn verifies_stage7(self) -> bool { matches!(self, Self::ThroughStage7 | Self::Full) }\n    fn verifies_evaluation(self) -> bool { matches!(self, Self::Full) }\n    fn allows_optional_evaluation(self) -> bool { matches!(self, Self::ThroughStage7 | Self::Full) }\n}\n\n".to_owned()
+fn jolt_verifier_program_items() -> String {
+    r"#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum JoltProofSlot {
+    Commitments,
+    Stage1Outer,
+    Stage2,
+    Stage3,
+    Stage4,
+    Stage5,
+    Stage6,
+    Stage7,
+    Evaluation,
+}
+
+pub type JoltVerifierStepKind = bolt_verifier_runtime::VerifierProgramStepKind;
+pub type JoltVerifierStepPlan = bolt_verifier_runtime::VerifierProgramStepPlan<JoltProofSlot>;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum JoltVerifierCheckpoint {
+    AfterStage5,
+    AfterStage6,
+    AfterStage7,
+    AfterEvaluation,
+}
+
+pub type JoltEvaluationPolicy = bolt_verifier_runtime::VerifierEvaluationPolicy;
+pub type JoltVerifierTarget = bolt_verifier_runtime::VerifierTarget<JoltVerifierCheckpoint>;
+pub type JoltVerifierTargetPlan = bolt_verifier_runtime::VerifierTargetPlan<JoltVerifierCheckpoint>;
+pub type JoltVerifierProgramPlan =
+    bolt_verifier_runtime::VerifierProgramPlan<JoltProofSlot, JoltVerifierCheckpoint>;
+pub type JoltVerifierProgramError =
+    bolt_verifier_runtime::VerifierProgramError<JoltProofSlot, JoltVerifierTarget>;
+
+pub const JOLT_TARGET_THROUGH_STAGE5: JoltVerifierTarget = JoltVerifierTarget {
+    checkpoint: JoltVerifierCheckpoint::AfterStage5,
+    evaluation: JoltEvaluationPolicy::Skip,
+};
+
+pub const JOLT_TARGET_THROUGH_STAGE6: JoltVerifierTarget = JoltVerifierTarget {
+    checkpoint: JoltVerifierCheckpoint::AfterStage6,
+    evaluation: JoltEvaluationPolicy::Skip,
+};
+
+pub const JOLT_TARGET_THROUGH_STAGE7: JoltVerifierTarget = JoltVerifierTarget {
+    checkpoint: JoltVerifierCheckpoint::AfterStage7,
+    evaluation: JoltEvaluationPolicy::VerifyIfPresent,
+};
+
+pub const JOLT_TARGET_FULL: JoltVerifierTarget = JoltVerifierTarget {
+    checkpoint: JoltVerifierCheckpoint::AfterEvaluation,
+    evaluation: JoltEvaluationPolicy::Required,
+};
+
+pub const JOLT_VERIFIER_STEPS: &[JoltVerifierStepPlan] = &[
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::ReceiveCommitments,
+        slot: JoltProofSlot::Commitments,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage1Outer,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage2,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage3,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage4,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage5,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage6,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage7,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifyPcsOpening,
+        slot: JoltProofSlot::Evaluation,
+    },
+];
+
+pub const JOLT_VERIFIER_TARGETS: &[JoltVerifierTargetPlan] = &[
+    JoltVerifierTargetPlan {
+        target: JOLT_TARGET_THROUGH_STAGE5,
+        step_count: 6,
+    },
+    JoltVerifierTargetPlan {
+        target: JOLT_TARGET_THROUGH_STAGE6,
+        step_count: 7,
+    },
+    JoltVerifierTargetPlan {
+        target: JOLT_TARGET_THROUGH_STAGE7,
+        step_count: 9,
+    },
+    JoltVerifierTargetPlan {
+        target: JOLT_TARGET_FULL,
+        step_count: 9,
+    },
+];
+
+pub const VERIFIER_PROGRAM: JoltVerifierProgramPlan = JoltVerifierProgramPlan {
+    steps: JOLT_VERIFIER_STEPS,
+    targets: JOLT_VERIFIER_TARGETS,
+};
+
+"
+    .to_owned()
+}
+
+fn jolt_verifier_execution_body() -> String {
+    "    let _verify_span = tracing::info_span!(\"bolt.verify\").entered();\n    execute_jolt_verifier_program(proof, inputs, programs, transcript, target)\n}\n\n".to_owned()
+}
+
+fn jolt_verifier_program_executor() -> String {
+    r#"fn execute_jolt_verifier_program<T>(
+    proof: &JoltProof,
+    inputs: JoltVerifierInputs<'_>,
+    programs: JoltVerifierPrograms,
+    transcript: &mut T,
+    target: JoltVerifierTarget,
+) -> Result<JoltVerificationArtifacts, JoltVerifyError>
+where
+    T: Transcript<Challenge = Fr>,
+{
+    let mut artifacts = JoltArtifactStore::default();
+    bolt_verifier_runtime::execute_verifier_program(programs.verifier, target, |step| {
+        execute_jolt_verifier_step(
+            step,
+            proof,
+            inputs,
+            programs,
+            transcript,
+            target.evaluation,
+            &mut artifacts,
+        )
+    })?;
+    artifacts.into_public_artifacts().map_err(JoltVerifyError::from)
+}
+
+fn execute_jolt_verifier_step<T>(
+    step: JoltVerifierStepPlan,
+    proof: &JoltProof,
+    inputs: JoltVerifierInputs<'_>,
+    programs: JoltVerifierPrograms,
+    transcript: &mut T,
+    evaluation: JoltEvaluationPolicy,
+    artifacts: &mut JoltArtifactStore,
+) -> Result<(), JoltVerifyError>
+where
+    T: Transcript<Challenge = Fr>,
+{
+    let step_plan = step;
+    match (step.kind, step.slot) {
+        (JoltVerifierStepKind::ReceiveCommitments, JoltProofSlot::Commitments) => {
+            artifacts.commitment = Some(commitment_stage::verify_commitment_phase_with_program(
+                programs.commitment,
+                &proof.commitments,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage1Outer) => {
+            artifacts.stage1_outer = Some(stage1_outer_stage::verify_stage1_outer_with_program(
+                programs.stage1_outer,
+                &proof.stage1_outer,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage2) => {
+            artifacts.stage2 = Some(stage2_stage::verify_stage2_with_program(
+                programs.stage2,
+                &proof.stage2,
+                inputs.stage2_openings,
+                inputs.stage2_ram,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage3) => {
+            artifacts.stage3 = Some(stage3_stage::verify_stage3_with_program(
+                programs.stage3,
+                &proof.stage3,
+                inputs.stage3_openings,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage4) => {
+            artifacts.stage4 = Some(stage4_stage::verify_stage4_with_program(
+                programs.stage4,
+                &proof.stage4,
+                inputs.stage4_openings,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage5) => {
+            artifacts.stage5 = Some(stage5_stage::verify_stage5_with_program(
+                programs.stage5,
+                &proof.stage5,
+                inputs.stage5_openings,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage6) => {
+            artifacts.stage6 = Some(stage6_stage::verify_stage6_with_program(
+                programs.stage6,
+                &proof.stage6,
+                inputs.stage6_openings,
+                inputs.stage6_data,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage7) => {
+            artifacts.stage7 = Some(stage7_stage::verify_stage7_with_program(
+                programs.stage7,
+                &proof.stage7,
+                inputs.stage7_openings,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifyPcsOpening, JoltProofSlot::Evaluation) => {
+            verify_jolt_evaluation_step(
+                evaluation,
+                proof,
+                inputs,
+                programs,
+                transcript,
+                artifacts,
+            )?;
+        }
+        _ => {
+            return Err(JoltVerifierProgramError::UnsupportedStep {
+                step: step_plan,
+                reason: "step kind and proof slot are incompatible",
+            }
+            .into());
+        }
+    }
+    Ok(())
+}
+
+fn verify_jolt_evaluation_step<T>(
+    evaluation: JoltEvaluationPolicy,
+    proof: &JoltProof,
+    inputs: JoltVerifierInputs<'_>,
+    programs: JoltVerifierPrograms,
+    transcript: &mut T,
+    artifacts: &JoltArtifactStore,
+) -> Result<(), JoltVerifyError>
+where
+    T: Transcript<Challenge = Fr>,
+{
+    if evaluation == JoltEvaluationPolicy::Skip {
+        return Ok(());
+    }
+    match (&proof.evaluation, inputs.evaluation_setup) {
+        (Some(evaluation_proof), Some(setup)) => {
+            verify_jolt_evaluation_proof(
+                programs.stage8,
+                evaluation_proof,
+                artifacts.commitment()?,
+                &proof.stage6,
+                &proof.stage7,
+                inputs.stage7_openings,
+                setup,
+                transcript,
+            )?;
+        }
+        (Some(_), None) => return Err(JoltEvaluationProofError::MissingVerifierSetup.into()),
+        (None, Some(_)) => return Err(JoltEvaluationProofError::MissingProof.into()),
+        (None, None) if evaluation == JoltEvaluationPolicy::Required => {
+            return Err(JoltEvaluationProofError::MissingProof.into());
+        }
+        (None, None) => {}
+    }
+    Ok(())
 }
 
-fn jolt_verifier_stage_verification() -> String {
-    "    let stage1_outer = stage1_outer_stage::verify_stage1_outer_with_program(programs.stage1_outer, &proof.stage1_outer, transcript)?;\n    let stage2 = stage2_stage::verify_stage2_with_program(programs.stage2, &proof.stage2, inputs.stage2_openings, inputs.stage2_ram, transcript)?;\n    let stage3 = stage3_stage::verify_stage3_with_program(programs.stage3, &proof.stage3, inputs.stage3_openings, transcript)?;\n    let stage4 = stage4_stage::verify_stage4_with_program(programs.stage4, &proof.stage4, inputs.stage4_openings, transcript)?;\n    let stage5 = stage5_stage::verify_stage5_with_program(programs.stage5, &proof.stage5, inputs.stage5_openings, transcript)?;\n    let stage6 = if target.verifies_stage6() {\n        stage6_stage::verify_stage6_with_program(programs.stage6, &proof.stage6, inputs.stage6_openings, inputs.stage6_data, transcript)?\n    } else {\n        stage6_stage::Stage6ExecutionArtifacts::default()\n    };\n    let stage7 = if target.verifies_stage7() {\n        stage7_stage::verify_stage7_with_program(programs.stage7, &proof.stage7, inputs.stage7_openings, transcript)?\n    } else {\n        stage7_stage::Stage7ExecutionArtifacts::default()\n    };\n".to_owned()
+#[derive(Default)]
+struct JoltArtifactStore {
+    commitment: Option<commitment_stage::CommitmentArtifacts>,
+    stage1_outer: Option<stage1_outer_stage::Stage1ExecutionArtifacts<Fr>>,
+    stage2: Option<stage2_stage::Stage2ExecutionArtifacts<Fr>>,
+    stage3: Option<stage3_stage::Stage3ExecutionArtifacts<Fr>>,
+    stage4: Option<stage4_stage::Stage4ExecutionArtifacts<Fr>>,
+    stage5: Option<stage5_stage::Stage5ExecutionArtifacts<Fr>>,
+    stage6: Option<stage6_stage::Stage6ExecutionArtifacts<Fr>>,
+    stage7: Option<stage7_stage::Stage7ExecutionArtifacts<Fr>>,
 }
 
-fn jolt_verifier_evaluation_check() -> String {
-    "    if target.allows_optional_evaluation() {\n        match (&proof.evaluation, inputs.evaluation_setup) {\n            (Some(evaluation), Some(setup)) => {\n                verify_jolt_evaluation_proof(\n                    programs.stage8,\n                    evaluation,\n                    &commitment,\n                    &proof.stage6,\n                    &proof.stage7,\n                    inputs.stage7_openings,\n                    setup,\n                    transcript,\n                )?;\n            }\n            (Some(_), None) => return Err(JoltEvaluationProofError::MissingVerifierSetup.into()),\n            (None, Some(_)) => return Err(JoltEvaluationProofError::MissingProof.into()),\n            (None, None) if target.verifies_evaluation() => return Err(JoltEvaluationProofError::MissingProof.into()),\n            (None, None) => {}\n        }\n    }\n".to_owned()
+impl JoltArtifactStore {
+    fn commitment(
+        &self,
+    ) -> Result<&commitment_stage::CommitmentArtifacts, JoltVerifierProgramError> {
+        self.commitment
+            .as_ref()
+            .ok_or(JoltVerifierProgramError::MissingArtifact {
+                slot: JoltProofSlot::Commitments,
+            })
+    }
+
+    fn into_public_artifacts(self) -> Result<JoltVerificationArtifacts, JoltVerifierProgramError> {
+        Ok(JoltVerificationArtifacts {
+            commitment: required_artifact(self.commitment, JoltProofSlot::Commitments)?,
+            stage1_outer: required_artifact(self.stage1_outer, JoltProofSlot::Stage1Outer)?,
+            stage2: required_artifact(self.stage2, JoltProofSlot::Stage2)?,
+            stage3: required_artifact(self.stage3, JoltProofSlot::Stage3)?,
+            stage4: required_artifact(self.stage4, JoltProofSlot::Stage4)?,
+            stage5: required_artifact(self.stage5, JoltProofSlot::Stage5)?,
+            stage6: self.stage6.unwrap_or_default(),
+            stage7: self.stage7.unwrap_or_default(),
+        })
+    }
+}
+
+fn required_artifact<T>(
+    artifact: Option<T>,
+    slot: JoltProofSlot,
+) -> Result<T, JoltVerifierProgramError> {
+    artifact.ok_or(JoltVerifierProgramError::MissingArtifact { slot })
+}
+
+"#
+    .to_owned()
 }
 
 fn jolt_verifier_input_helpers(prefix: &str) -> String {
@@ -405,6 +739,59 @@ fn jolt_verifier_evaluation_helpers(prefix: &str, field_type: &str) -> String {
 pub type {prefix}Stage6BytecodeReadRafData = crate::stages::stage6::Stage6BytecodeReadRafData;
 pub type {prefix}Stage6VerifierData = crate::stages::stage6::Stage6VerifierData;
 
+impl stage8_stage::Stage8NamedEvalView<{field_type}> for {prefix}NamedEval {{
+    fn name(&self) -> &'static str {{
+        self.name
+    }}
+
+    fn value(&self) -> {field_type} {{
+        self.value
+    }}
+}}
+
+impl stage8_stage::Stage8SumcheckOutputView<{field_type}> for {prefix}SumcheckOutput {{
+    type Eval = {prefix}NamedEval;
+
+    fn point(&self) -> &[{field_type}] {{
+        &self.point
+    }}
+
+    fn evals(&self) -> &[Self::Eval] {{
+        &self.evals
+    }}
+}}
+
+impl stage8_stage::Stage8OpeningInputView<{field_type}>
+    for stage7_stage::Stage7OpeningInputValue<{field_type}>
+{{
+    fn symbol(&self) -> &'static str {{
+        self.symbol
+    }}
+
+    fn point(&self) -> &[{field_type}] {{
+        &self.point
+    }}
+}}
+
+impl From<stage8_stage::Stage8EvaluationOpeningPointError> for {prefix}EvaluationProofError {{
+    fn from(error: stage8_stage::Stage8EvaluationOpeningPointError) -> Self {{
+        match error {{
+            stage8_stage::Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint => {{
+                Self::MissingStage7EvaluationPoint
+            }}
+            stage8_stage::Stage8EvaluationOpeningPointError::InvalidPointLength {{
+                artifact,
+                expected,
+                actual,
+            }} => Self::InvalidPointLength {{
+                artifact,
+                expected,
+                actual,
+            }},
+        }}
+    }}
+}}
+
 #[expect(
     clippy::too_many_arguments,
     reason = "generated verifier entry point follows the Jolt proof artifact boundary"
@@ -452,11 +839,6 @@ struct EvaluationProofState {{
     joint_commitment: DoryCommitment,
 }}
 
-struct EvaluationClaim {{
-    oracle: &'static str,
-    value: {field_type},
-}}
-
 fn evaluation_proof_state<T>(
     program: &'static stage8_stage::Stage8EvaluationProgramPlan,
     commitments: &commitment_stage::CommitmentArtifacts,
@@ -468,14 +850,22 @@ fn evaluation_proof_state<T>(
 where
     T: Transcript<Challenge = {field_type}>,
 {{
-    let (sumcheck_address_point, stage7_values) = stage7_claim_values(program, stage7)?;
-    let address_point = reverse_point(&sumcheck_address_point);
-    let opening_point = stage7_evaluation_opening_point(program, &address_point, stage7_openings)?;
+    let (sumcheck_address_point, stage7_values) =
+        stage8_stage::stage7_claim_values(program, &stage7.sumchecks)
+            .ok_or({prefix}EvaluationProofError::MissingStage7RaEval)?;
+    let address_point = stage8_stage::reverse_point(&sumcheck_address_point);
+    let (opening_point, _) =
+        stage8_stage::stage7_evaluation_opening_point(program, &address_point, stage7_openings)?;
     let lagrange_factor = EqPolynomial::<{field_type}>::zero_selector(&address_point);
-    let claims = evaluation_claims(program, stage6, &stage7_values, lagrange_factor)?;
-
-    append_rlc_claims(transcript, &claims);
-    let gamma_powers = gamma_powers(transcript, claims.len());
+    let claims =
+        stage8_stage::evaluation_claims(program, &stage6.sumchecks, &stage7_values, lagrange_factor)
+            .map_err(|error| {prefix}EvaluationProofError::MissingStageEval {{
+                stage: error.stage,
+                eval: error.eval,
+            }})?;
+
+    stage8_stage::append_rlc_claims(transcript, &claims);
+    let gamma_powers = stage8_stage::gamma_powers(transcript, claims.len());
     let joint_claim = claims
         .iter()
         .zip(&gamma_powers)
@@ -490,130 +880,9 @@ where
     }})
 }}
 
-fn stage_eval(
-    proof: &{prefix}StageProof,
-    stage: &'static str,
-    eval_name: &'static str,
-) -> Result<{field_type}, {prefix}EvaluationProofError> {{
-    for output in &proof.sumchecks {{
-        if let Some(eval) = output.evals.iter().find(|eval| eval.name == eval_name) {{
-            return Ok(eval.value);
-        }}
-    }}
-    Err({prefix}EvaluationProofError::MissingStageEval {{
-        stage,
-        eval: eval_name,
-    }})
-}}
-
-fn evaluation_claims(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    stage6: &{prefix}StageProof,
-    stage7_values: &BTreeMap<&'static str, {field_type}>,
-    lagrange_factor: {field_type},
-) -> Result<Vec<EvaluationClaim>, {prefix}EvaluationProofError> {{
-    let mut claims = Vec::with_capacity(program.opening_claims.len());
-    for plan in program.opening_claims {{
-        let value = match plan.source_stage {{
-            "stage6" => stage_eval(stage6, plan.source_stage, plan.source_claim)? * lagrange_factor,
-            "stage7" => *stage7_values.get(plan.source_claim).ok_or(
-                {prefix}EvaluationProofError::MissingStageEval {{
-                    stage: plan.source_stage,
-                    eval: plan.source_claim,
-                }},
-            )?,
-            _ => {{
-                return Err({prefix}EvaluationProofError::MissingStageEval {{
-                    stage: plan.source_stage,
-                    eval: plan.source_claim,
-                }});
-            }}
-        }};
-        claims.push(EvaluationClaim {{
-            oracle: plan.oracle,
-            value,
-        }});
-    }}
-    Ok(claims)
-}}
-
-fn stage7_claim_values(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    proof: &{prefix}StageProof,
-) -> Result<(Vec<{field_type}>, BTreeMap<&'static str, {field_type}>), {prefix}EvaluationProofError> {{
-    let stage7_plans = program
-        .opening_claims
-        .iter()
-        .filter(|plan| plan.source_stage == "stage7")
-        .collect::<Vec<_>>();
-    for output in &proof.sumchecks {{
-        let mut values = BTreeMap::new();
-        for plan in &stage7_plans {{
-            if let Some(eval) = output.evals.iter().find(|eval| eval.name == plan.source_claim) {{
-                let _ = values.insert(plan.source_claim, eval.value);
-            }}
-        }}
-        if values.len() == stage7_plans.len() {{
-            return Ok((output.point.clone(), values));
-        }}
-    }}
-    Err({prefix}EvaluationProofError::MissingStage7RaEval)
-}}
-
-fn reverse_point(point: &[{field_type}]) -> Vec<{field_type}> {{
-    point.iter().rev().copied().collect()
-}}
-
-fn stage7_evaluation_opening_point(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    address_point: &[{field_type}],
-    stage7_openings: &[stage7_stage::Stage7OpeningInputValue<{field_type}>],
-) -> Result<Vec<{field_type}>, {prefix}EvaluationProofError> {{
-    let cycle_source_symbol = program.evaluation_point_source.source_claim;
-    let cycle_source = stage7_openings
-        .iter()
-        .find(|input| input.symbol == cycle_source_symbol)
-        .ok_or({prefix}EvaluationProofError::MissingStage7EvaluationPoint)?;
-    if cycle_source.point.len() < address_point.len() {{
-        return Err({prefix}EvaluationProofError::InvalidPointLength {{
-            artifact: cycle_source_symbol,
-            expected: address_point.len(),
-            actual: cycle_source.point.len(),
-        }});
-    }}
-    let mut point = Vec::with_capacity(cycle_source.point.len());
-    point.extend_from_slice(address_point);
-    point.extend_from_slice(&cycle_source.point[address_point.len()..]);
-    Ok(point)
-}}
-
-fn append_rlc_claims<T>(transcript: &mut T, claims: &[EvaluationClaim])
-where
-    T: Transcript<Challenge = {field_type}>,
-{{
-    transcript.append(&LabelWithCount(b"rlc_claims", claims.len() as u64));
-    for claim in claims {{
-        claim.value.append_to_transcript(transcript);
-    }}
-}}
-
-fn gamma_powers<T>(transcript: &mut T, count: usize) -> Vec<{field_type}>
-where
-    T: Transcript<Challenge = {field_type}>,
-{{
-    let gamma = transcript.challenge();
-    let mut powers = Vec::with_capacity(count);
-    let mut power = {field_type}::from_u64(1);
-    for _ in 0..count {{
-        powers.push(power);
-        power *= gamma;
-    }}
-    powers
-}}
-
 fn joint_commitment(
     commitments: &commitment_stage::CommitmentArtifacts,
-    claims: &[EvaluationClaim],
+    claims: &[stage8_stage::Stage8EvaluationClaim<{field_type}>],
     gamma_powers: &[{field_type}],
 ) -> Result<DoryCommitment, {prefix}EvaluationProofError> {{
     let mut coefficients = BTreeMap::<&'static str, {field_type}>::new();
@@ -1996,7 +2265,62 @@ fn stage5_opening_claim(
 
 fn jolt_prover_evaluation_helpers(field_type: &str) -> String {
     format!(
-        r#"pub fn prove_jolt_evaluation_proof<I, T>(
+        r#"impl stage8_stage::Stage8NamedEvalView<{field_type}> for stage7::Stage7NamedEval<{field_type}> {{
+    fn name(&self) -> &'static str {{
+        self.name
+    }}
+
+    fn value(&self) -> {field_type} {{
+        self.value
+    }}
+}}
+
+impl stage8_stage::Stage8SumcheckOutputView<{field_type}>
+    for stage7::Stage7SumcheckOutput<{field_type}>
+{{
+    type Eval = stage7::Stage7NamedEval<{field_type}>;
+
+    fn point(&self) -> &[{field_type}] {{
+        &self.point
+    }}
+
+    fn evals(&self) -> &[Self::Eval] {{
+        &self.evals
+    }}
+}}
+
+impl stage8_stage::Stage8OpeningInputView<{field_type}>
+    for stage7::Stage7OpeningInputValue<{field_type}>
+{{
+    fn symbol(&self) -> &'static str {{
+        self.symbol
+    }}
+
+    fn point(&self) -> &[{field_type}] {{
+        &self.point
+    }}
+}}
+
+impl From<stage8_stage::Stage8EvaluationOpeningPointError> for JoltEvaluationProveError {{
+    fn from(error: stage8_stage::Stage8EvaluationOpeningPointError) -> Self {{
+        match error {{
+            stage8_stage::Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint => {{
+                Self::MissingStage7EvaluationPoint
+            }}
+            stage8_stage::Stage8EvaluationOpeningPointError::InvalidPointLength {{
+                artifact,
+                expected,
+                actual,
+            }} => Self::InvalidPointLength {{
+                artifact,
+                expected,
+                actual,
+            }},
+        }}
+    }}
+}}
+
+pub fn prove_jolt_evaluation_proof<I, T>(
     program: &'static stage8_stage::Stage8EvaluationProgramPlan,
     commitment_inputs: &mut I,
     prover_setup: &DoryProverSetup,
@@ -2011,17 +2335,24 @@ where
     T: Transcript<Challenge = {field_type}>,
 {{
     let _claims_span = tracing::info_span!("bolt.evaluate.claims").entered();
-    let (sumcheck_address_point, stage7_values) = stage7_claim_values(program, stage7)?;
-    let address_point = reverse_point(&sumcheck_address_point);
+    let (sumcheck_address_point, stage7_values) =
+        stage8_stage::stage7_claim_values(program, &stage7.sumchecks)
+            .ok_or(JoltEvaluationProveError::MissingStage7RaEval)?;
+    let address_point = stage8_stage::reverse_point(&sumcheck_address_point);
     let (opening_point, log_t) =
-        stage7_evaluation_opening_point(program, &address_point, stage7_openings)?;
+        stage8_stage::stage7_evaluation_opening_point(program, &address_point, stage7_openings)?;
     let lagrange_factor = EqPolynomial::<{field_type}>::zero_selector(&address_point);
-    let claims = evaluation_claims(program, stage6, &stage7_values, lagrange_factor)?;
+    let claims =
+        stage8_stage::evaluation_claims(program, &stage6.sumchecks, &stage7_values, lagrange_factor)
+            .map_err(|error| JoltEvaluationProveError::MissingStageEval {{
+                stage: error.stage,
+                eval: error.eval,
+            }})?;
     drop(_claims_span);
 
     let _rlc_span = tracing::info_span!("bolt.evaluate.rlc_claims").entered();
-    append_rlc_claims(transcript, &claims);
-    let gamma_powers = gamma_powers(transcript, claims.len());
+    stage8_stage::append_rlc_claims(transcript, &claims);
+    let gamma_powers = stage8_stage::gamma_powers(transcript, claims.len());
     let joint_claim = claims
         .iter()
         .zip(&gamma_powers)
@@ -2062,137 +2393,9 @@ where
     Ok(JoltEvaluationProof {{ joint_opening_proof }})
 }}
 
-struct EvaluationClaim {{
-    oracle: &'static str,
-    source_stage: &'static str,
-    value: {field_type},
-}}
-
-fn stage6_eval_claim(
-    artifacts: &stage6::Stage6ExecutionArtifacts<{field_type}>,
-    eval_name: &'static str,
-) -> Result<{field_type}, JoltEvaluationProveError> {{
-    for output in &artifacts.sumchecks {{
-        if let Some(eval) = output.evals.iter().find(|eval| eval.name == eval_name) {{
-            return Ok(eval.value);
-        }}
-    }}
-    Err(JoltEvaluationProveError::MissingStageEval {{
-        stage: "stage6",
-        eval: eval_name,
-    }})
-}}
-
-fn evaluation_claims(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    stage6: &stage6::Stage6ExecutionArtifacts<{field_type}>,
-    stage7_values: &std::collections::BTreeMap<&'static str, {field_type}>,
-    lagrange_factor: {field_type},
-) -> Result<Vec<EvaluationClaim>, JoltEvaluationProveError> {{
-    let mut claims = Vec::with_capacity(program.opening_claims.len());
-    for plan in program.opening_claims {{
-        let value = match plan.source_stage {{
-            "stage6" => stage6_eval_claim(stage6, plan.source_claim)? * lagrange_factor,
-            "stage7" => *stage7_values.get(plan.source_claim).ok_or(
-                JoltEvaluationProveError::MissingStageEval {{
-                    stage: plan.source_stage,
-                    eval: plan.source_claim,
-                }},
-            )?,
-            _ => {{
-                return Err(JoltEvaluationProveError::MissingStageEval {{
-                    stage: plan.source_stage,
-                    eval: plan.source_claim,
-                }});
-            }}
-        }};
-        claims.push(EvaluationClaim {{
-            oracle: plan.oracle,
-            source_stage: plan.source_stage,
-            value,
-        }});
-    }}
-    Ok(claims)
-}}
-
-fn stage7_claim_values(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    artifacts: &stage7::Stage7ExecutionArtifacts<{field_type}>,
-) -> Result<(Vec<{field_type}>, std::collections::BTreeMap<&'static str, {field_type}>), JoltEvaluationProveError> {{
-    let stage7_plans = program
-        .opening_claims
-        .iter()
-        .filter(|plan| plan.source_stage == "stage7")
-        .collect::<Vec<_>>();
-    for output in &artifacts.sumchecks {{
-        let mut values = std::collections::BTreeMap::new();
-        for plan in &stage7_plans {{
-            if let Some(eval) = output.evals.iter().find(|eval| eval.name == plan.source_claim) {{
-                let _ = values.insert(plan.source_claim, eval.value);
-            }}
-        }}
-        if values.len() == stage7_plans.len() {{
-            return Ok((output.point.clone(), values));
-        }}
-    }}
-    Err(JoltEvaluationProveError::MissingStage7RaEval)
-}}
-
-fn reverse_point(point: &[{field_type}]) -> Vec<{field_type}> {{
-    point.iter().rev().copied().collect()
-}}
-
-fn stage7_evaluation_opening_point(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    address_point: &[{field_type}],
-    stage7_openings: &[stage7::Stage7OpeningInputValue<{field_type}>],
-) -> Result<(Vec<{field_type}>, usize), JoltEvaluationProveError> {{
-    let cycle_source_symbol = program.evaluation_point_source.source_claim;
-    let cycle_source = stage7_openings
-        .iter()
-        .find(|input| input.symbol == cycle_source_symbol)
-        .ok_or(JoltEvaluationProveError::MissingStage7EvaluationPoint)?;
-    if cycle_source.point.len() < address_point.len() {{
-        return Err(JoltEvaluationProveError::InvalidPointLength {{
-            artifact: cycle_source_symbol,
-            expected: address_point.len(),
-            actual: cycle_source.point.len(),
-        }});
-    }}
-    let cycle_len = cycle_source.point.len() - address_point.len();
-    let mut point = Vec::with_capacity(cycle_source.point.len());
-    point.extend_from_slice(address_point);
-    point.extend_from_slice(&cycle_source.point[address_point.len()..]);
-    Ok((point, cycle_len))
-}}
-
-fn append_rlc_claims<T>(transcript: &mut T, claims: &[EvaluationClaim])
-where
-    T: Transcript<Challenge = {field_type}>,
-{{
-    transcript.append(&LabelWithCount(b"rlc_claims", claims.len() as u64));
-    for claim in claims {{
-        claim.value.append_to_transcript(transcript);
-    }}
-}}
-
-fn gamma_powers<T>(transcript: &mut T, count: usize) -> Vec<{field_type}>
-where
-    T: Transcript<Challenge = {field_type}>,
-{{
-    let gamma = transcript.challenge();
-    let mut powers = Vec::with_capacity(count);
-    let mut power = {field_type}::from_u64(1);
-    for _ in 0..count {{
-        powers.push(power);
-        power *= gamma;
-    }}
-    powers
-}}
-
 fn materialize_joint_polynomial<I>(
     commitment_inputs: &mut I,
-    claims: &[EvaluationClaim],
+    claims: &[stage8_stage::Stage8EvaluationClaim<{field_type}>],
     gamma_powers: &[{field_type}],
     log_t: usize,
     main_num_vars: usize,
@@ -2204,7 +2407,7 @@ where
     let main_len = target_len(main_num_vars)?;
     let mut joint = vec![{field_type}::from_u64(0); main_len];
     for (claim, gamma) in claims.iter().zip(gamma_powers) {{
-        if claim.source_stage == "stage6" {{
+        if claim.source_stage == stage8_stage::Stage8SourceStage::Stage6 {{
             add_oracle_scaled(commitment_inputs, &mut joint, claim.oracle, log_t, trace_len, *gamma)?;
         }} else {{
             add_oracle_scaled(
@@ -2279,7 +2482,7 @@ where
 
 fn joint_opening_hint(
     commitments: &commitment_stage::CommitmentArtifacts,
-    claims: &[EvaluationClaim],
+    claims: &[stage8_stage::Stage8EvaluationClaim<{field_type}>],
     gamma_powers: &[{field_type}],
 ) -> Result<DoryHint, JoltEvaluationProveError> {{
     let mut coefficients = std::collections::BTreeMap::<&'static str, {field_type}>::new();
diff --git a/crates/bolt/src/protocols/jolt/cpu_attrs.rs b/crates/bolt/src/protocols/jolt/cpu_attrs.rs
new file mode 100644
index 0000000000..e6499a9779
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/cpu_attrs.rs
@@ -0,0 +1,198 @@
+use melior::ir::operation::{OperationLike, OperationResult};
+use melior::ir::{Attribute, OperationRef};
+
+use crate::emit::rust::EmitError;
+use crate::ir::{string_attribute_value, symbol_attribute_value};
+
+pub(crate) fn string_attr(
+    operation: OperationRef<'_, '_>,
+    attr: &str,
+) -> Result<String, EmitError> {
+    operation
+        .attribute(attr)
+        .ok()
+        .and_then(string_attribute_value)
+        .ok_or_else(|| attr_error(operation, attr, "string"))
+}
+
+pub(crate) fn symbol_attr(
+    operation: OperationRef<'_, '_>,
+    attr: &str,
+) -> Result<String, EmitError> {
+    operation
+        .attribute(attr)
+        .ok()
+        .and_then(symbol_attribute_value)
+        .ok_or_else(|| attr_error(operation, attr, "symbol"))
+}
+
+pub(crate) fn symbol_array_attr(
+    operation: OperationRef<'_, '_>,
+    attr: &str,
+) -> Result<Vec<String>, EmitError> {
+    let attribute = operation
+        .attribute(attr)
+        .map(|attribute| attribute.to_string())
+        .ok()
+        .ok_or_else(|| attr_error(operation, attr, "symbol array"))?;
+    parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array"))
+}
+
+pub(crate) fn optional_symbol_array_attr(
+    operation: OperationRef<'_, '_>,
+    attr: &str,
+) -> Result<Vec<String>, EmitError> {
+    let values = symbol_array_attr(operation, attr)?;
+    if values.len() <= 1 {
+        Ok(values)
+    } else {
+        Err(EmitError::new(format!(
+            "{} attr `{attr}` expected zero or one symbols, got {}",
+            operation_name(operation),
+            values.len()
+        )))
+    }
+}
+
+pub(crate) fn string_array_attr(
+    operation: OperationRef<'_, '_>,
+    attr: &str,
+) -> Result<Vec<String>, EmitError> {
+    let attribute = operation
+        .attribute(attr)
+        .map(|attribute| attribute.to_string())
+        .ok()
+        .ok_or_else(|| attr_error(operation, attr, "string array"))?;
+    parse_string_array(&attribute).ok_or_else(|| attr_error(operation, attr, "string array"))
+}
+
+pub(crate) fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<usize, EmitError> {
+    operation
+        .attribute(attr)
+        .map(parse_integer_attr)
+        .ok()
+        .flatten()
+        .ok_or_else(|| attr_error(operation, attr, "integer"))
+}
+
+pub(crate) fn signed_int_attr(
+    operation: OperationRef<'_, '_>,
+    attr: &str,
+) -> Result<isize, EmitError> {
+    operation
+        .attribute(attr)
+        .map(parse_signed_integer_attr)
+        .ok()
+        .flatten()
+        .ok_or_else(|| attr_error(operation, attr, "signed integer"))
+}
+
+pub(crate) fn int_array_attr(
+    operation: OperationRef<'_, '_>,
+    attr: &str,
+) -> Result<Vec<usize>, EmitError> {
+    let attribute = operation
+        .attribute(attr)
+        .map(|attribute| attribute.to_string())
+        .ok()
+        .ok_or_else(|| attr_error(operation, attr, "integer array"))?;
+    parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array"))
+}
+
+pub(crate) fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError {
+    EmitError::new(format!(
+        "{} attr `{attr}` is not a {expected}",
+        operation_name(operation)
+    ))
+}
+
+pub(crate) fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String {
+    operation
+        .name()
+        .as_string_ref()
+        .as_str()
+        .unwrap_or("<invalid-operation-name>")
+        .to_owned()
+}
+
+pub(crate) fn operand_symbols(
+    operation: OperationRef<'_, '_>,
+    start_index: usize,
+) -> Result<Vec<String>, EmitError> {
+    (start_index..operation.operand_count())
+        .map(|index| operand_symbol(operation, index))
+        .collect()
+}
+
+pub(crate) fn operand_symbol(
+    operation: OperationRef<'_, '_>,
+    index: usize,
+) -> Result<String, EmitError> {
+    let operand = operation.operand(index).map_err(|_| {
+        EmitError::new(format!(
+            "{} requires operand {index}",
+            operation_name(operation)
+        ))
+    })?;
+    let owner = OperationResult::try_from(operand).map_err(|_| {
+        EmitError::new(format!(
+            "{} operand {index} must be an op result",
+            operation_name(operation)
+        ))
+    })?;
+    string_attr(owner.owner(), "sym_name")
+}
+
+fn parse_symbol_array(attribute: &str) -> Option<Vec<String>> {
+    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
+    if inner.is_empty() {
+        return Some(Vec::new());
+    }
+    inner
+        .split(',')
+        .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned))
+        .collect()
+}
+
+fn parse_string_array(attribute: &str) -> Option<Vec<String>> {
+    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
+    if inner.is_empty() {
+        return Some(Vec::new());
+    }
+    inner
+        .split(',')
+        .map(|item| {
+            item.trim()
+                .strip_prefix('"')?
+                .strip_suffix('"')
+                .map(ToOwned::to_owned)
+        })
+        .collect()
+}
+
+fn parse_integer_attr(attribute: Attribute<'_>) -> Option<usize> {
+    attribute
+        .to_string()
+        .split_whitespace()
+        .next()
+        .and_then(|value| value.parse().ok())
+}
+
+fn parse_signed_integer_attr(attribute: Attribute<'_>) -> Option<isize> {
+    attribute
+        .to_string()
+        .split_whitespace()
+        .next()
+        .and_then(|value| value.parse().ok())
+}
+
+fn parse_int_array(attribute: &str) -> Option<Vec<usize>> {
+    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
+    if inner.is_empty() {
+        return Some(Vec::new());
+    }
+    inner
+        .split(',')
+        .map(|item| item.trim().parse().ok())
+        .collect()
+}
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/commitment.rs b/crates/bolt/src/protocols/jolt/emit/rust/commitment.rs
index e5460c75c6..dcb1bceaad 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/commitment.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/commitment.rs
@@ -1101,8 +1101,15 @@ pub enum CommitmentPhaseError {
         for (index, plan) in self.batch_plans.iter().enumerate() {
             let oracles = plan
                 .oracles
-                .iter()
-                .map(|oracle| format!("    {},", rust_str(oracle)))
+                .chunks(8)
+                .map(|chunk| {
+                    let entries = chunk
+                        .iter()
+                        .map(|oracle| rust_str(oracle))
+                        .collect::<Vec<_>>()
+                        .join(", ");
+                    format!("    {entries},")
+                })
                 .collect::<Vec<_>>()
                 .join("\n");
             push_format(
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/mod.rs b/crates/bolt/src/protocols/jolt/emit/rust/mod.rs
index 50f36ba9f7..3d27780a96 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/mod.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/mod.rs
@@ -1,4 +1,6 @@
 mod commitment;
+mod plan_tokens;
+mod relation_outputs;
 mod stage1;
 mod stage2;
 mod stage3;
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs
new file mode 100644
index 0000000000..a6a9af1c5e
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs
@@ -0,0 +1,579 @@
+use std::collections::BTreeSet;
+
+use crate::emit::rust::EmitError;
+use crate::ir::Role;
+use crate::protocols::jolt::rust_target_plan::{
+    ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode,
+    ProgramStepKind, RustTargetPlanError, ScalarExprKind, SumcheckPointOrder,
+    TranscriptSqueezeKind,
+};
+use crate::protocols::jolt::verifier_plan::{
+    VerifierFieldExprPlan, VerifierScalarExprOperand, VerifierScalarExprPlan,
+};
+use crate::protocols::jolt::verifier_value_rows::{CpuFieldExprPlan, CpuScalarExprPlan};
+use crate::protocols::jolt::verifier_values::{
+    VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointSourceSet,
+    VerifierPointValueSet, VerifierScalarSourceSet, VerifierScalarValueSet,
+};
+
+pub(super) fn role_program_step_kind_expr(
+    stage_type_prefix: &str,
+    role: &Role,
+    kind: &str,
+) -> Result<String, EmitError> {
+    if role == &Role::Prover {
+        return Ok(format!("{kind:?}"));
+    }
+    program_step_kind_expr(stage_type_prefix, kind)
+}
+
+pub(super) fn role_transcript_squeeze_kind_expr(
+    stage_type_prefix: &str,
+    role: &Role,
+    kind: &str,
+) -> Result<String, EmitError> {
+    if role == &Role::Prover {
+        return Ok(format!("{kind:?}"));
+    }
+    transcript_squeeze_kind_expr(stage_type_prefix, kind)
+}
+
+pub(super) fn role_claim_kind_expr(
+    stage_type_prefix: &str,
+    role: &Role,
+    kind: &str,
+) -> Result<String, EmitError> {
+    if role == &Role::Prover {
+        return Ok(format!("{kind:?}"));
+    }
+    claim_kind_expr(stage_type_prefix, kind)
+}
+
+pub(super) fn rust_str_slice_expr(values: &[String]) -> String {
+    if values.is_empty() {
+        return "&[]".to_owned();
+    }
+    let values = values
+        .iter()
+        .map(|value| format!("{value:?}"))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("&[{values}]")
+}
+
+pub(super) fn rust_str(value: &str) -> String {
+    format!("{value:?}")
+}
+
+pub(super) fn rust_option_str(value: Option<&str>) -> String {
+    value.map_or_else(
+        || "None".to_owned(),
+        |value| format!("Some({})", rust_str(value)),
+    )
+}
+
+pub(super) fn emit_str_array(name: &str, values: &[String]) -> String {
+    if values.is_empty() {
+        return format!("pub const {name}: &[&str] = &[];\n\n");
+    }
+    if let [value] = values {
+        return format!("pub const {name}: &[&str] = &[{}];\n\n", rust_str(value));
+    }
+    let entries = values
+        .iter()
+        .map(|value| format!("    {},", rust_str(value)))
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!("pub const {name}: &[&str] = &[\n{entries}\n];\n\n")
+}
+
+pub(super) fn emit_usize_array(name: &str, values: &[usize]) -> String {
+    let entries = values
+        .iter()
+        .map(usize::to_string)
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("pub const {name}: &[usize] = &[{entries}];\n\n")
+}
+
+pub(super) fn intern_str_array(
+    source: &mut String,
+    arrays: &mut Vec<(Vec<String>, String)>,
+    name_prefix: &str,
+    values: &[String],
+) -> String {
+    if let Some((_, name)) = arrays
+        .iter()
+        .find(|(existing, _)| existing.as_slice() == values)
+    {
+        return name.clone();
+    }
+    let name = format!("{name_prefix}_{}", arrays.len());
+    source.push_str(&emit_str_array(&name, values));
+    arrays.push((values.to_vec(), name.clone()));
+    name
+}
+
+pub(super) fn require_supported_symbol(
+    kind: &str,
+    actual: &str,
+    expected: &str,
+) -> Result<(), EmitError> {
+    if actual == expected {
+        Ok(())
+    } else {
+        Err(EmitError::new(format!(
+            "unsupported {kind} @{actual}; expected @{expected}"
+        )))
+    }
+}
+
+pub(super) fn verify_count(
+    kind: &str,
+    symbol: &str,
+    expected: usize,
+    actual: usize,
+) -> Result<(), EmitError> {
+    if expected == actual {
+        Ok(())
+    } else {
+        Err(EmitError::new(format!(
+            "{kind} @{symbol} count mismatch: expected {expected}, got {actual}"
+        )))
+    }
+}
+
+pub(super) fn symbols<'a>(values: impl Iterator<Item = &'a String>) -> BTreeSet<String> {
+    values.cloned().collect()
+}
+
+pub(super) struct FieldExprFlowVerification<'a> {
+    pub cpu_exprs: &'a [CpuFieldExprPlan],
+    pub verifier_exprs: Option<&'a [VerifierFieldExprPlan]>,
+    pub field_values: &'a VerifierScalarSourceSet,
+    pub verifier_field_values: Option<&'a VerifierScalarValueSet>,
+}
+
+pub(super) fn verify_field_expr_flow(
+    verification: FieldExprFlowVerification<'_>,
+) -> Result<(), EmitError> {
+    let FieldExprFlowVerification {
+        cpu_exprs,
+        verifier_exprs,
+        field_values,
+        verifier_field_values,
+    } = verification;
+    if let (Some(exprs), Some(field_values)) = (verifier_exprs, verifier_field_values) {
+        for expr in exprs {
+            for operand in &expr.operands {
+                if !field_values.contains_ref(operand) {
+                    return Err(EmitError::new(format!(
+                        "field expr @{} references missing field value @{}",
+                        expr.symbol,
+                        operand.symbol()
+                    )));
+                }
+            }
+        }
+    } else {
+        for expr in cpu_exprs {
+            verify_count(
+                "field expr operands",
+                &expr.symbol,
+                expr.operand_names.len(),
+                expr.operands.len(),
+            )?;
+            let _kind = FieldExprKind::from_cpu_attr(&expr.formula)
+                .map_err(|error| EmitError::new(error.to_string()))?;
+            for operand in &expr.operands {
+                if !field_values.contains(operand) {
+                    return Err(EmitError::new(format!(
+                        "field expr @{} references missing field value @{operand}",
+                        expr.symbol
+                    )));
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+pub(super) struct ScalarExprVerification<'a> {
+    pub stage: &'static str,
+    pub symbol: &'a str,
+    pub formula: &'a str,
+    pub operand_names: &'a [String],
+    pub operands: &'a [String],
+    pub field_values: &'a VerifierScalarSourceSet,
+    pub field_vector_values: Option<&'a VerifierFieldVectorValueSet>,
+    pub point_values: Option<&'a VerifierPointSourceSet>,
+}
+
+pub(super) fn verify_scalar_expr_operands(
+    verification: ScalarExprVerification<'_>,
+) -> Result<(), EmitError> {
+    let ScalarExprVerification {
+        stage,
+        symbol,
+        formula,
+        operand_names,
+        operands,
+        field_values,
+        field_vector_values,
+        point_values,
+    } = verification;
+    verify_count(
+        "scalar expr operands",
+        symbol,
+        operand_names.len(),
+        operands.len(),
+    )?;
+    let kind = ScalarExprKind::from_cpu_attr(formula)
+        .map_err(|error| EmitError::new(error.to_string()))?;
+    match kind {
+        ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => {
+            let Some(field_vector_values) = field_vector_values else {
+                return Err(EmitError::new(format!(
+                    "{stage} scalar expr @{symbol} uses unsupported field-vector formula `{formula}`"
+                )));
+            };
+            verify_count("field vector expr operands", symbol, 1, operands.len())?;
+            let operand = &operands[0];
+            if !field_vector_values
+                .contains_ref(&VerifierFieldVectorValueRef::new(operand.as_str()))
+            {
+                return Err(EmitError::new(format!(
+                    "field vector expr @{symbol} references missing field vector @{operand}"
+                )));
+            }
+        }
+        ScalarExprKind::PowerStridedWeightedSum { .. } => {
+            for operand in operands {
+                if !field_values.contains(operand) {
+                    return Err(EmitError::new(format!(
+                        "scalar expr @{symbol} references missing field value @{operand}"
+                    )));
+                }
+            }
+        }
+        ScalarExprKind::StructuredPolynomial { .. } => {
+            verify_count(
+                "structured polynomial scalar expr operands",
+                symbol,
+                2,
+                operands.len(),
+            )?;
+            for operand in operands {
+                if !point_values.is_some_and(|values| values.contains(operand)) {
+                    return Err(EmitError::new(format!(
+                        "structured polynomial scalar expr @{symbol} references missing point value @{operand}"
+                    )));
+                }
+            }
+        }
+        ScalarExprKind::PointElement { .. } => {
+            verify_count(
+                "point element scalar expr operands",
+                symbol,
+                1,
+                operands.len(),
+            )?;
+            let Some(point_values) = point_values else {
+                return Err(EmitError::new(format!(
+                    "{stage} scalar expr @{symbol} uses point element formula without point sources"
+                )));
+            };
+            let operand = &operands[0];
+            if !point_values.contains(operand) {
+                return Err(EmitError::new(format!(
+                    "point element scalar expr @{symbol} references missing point @{operand}"
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+pub(super) struct VerifierScalarExprVerification<'a> {
+    pub stage: &'static str,
+    pub expr: &'a VerifierScalarExprPlan,
+    pub field_values: &'a VerifierScalarValueSet,
+    pub field_vector_values: Option<&'a VerifierFieldVectorValueSet>,
+    pub point_values: Option<&'a VerifierPointValueSet>,
+}
+
+pub(super) fn verify_verifier_scalar_expr_operands(
+    verification: VerifierScalarExprVerification<'_>,
+) -> Result<(), EmitError> {
+    let VerifierScalarExprVerification {
+        stage,
+        expr,
+        field_values,
+        field_vector_values,
+        point_values,
+    } = verification;
+    match expr.kind {
+        ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => {
+            let Some(field_vector_values) = field_vector_values else {
+                return Err(EmitError::new(format!(
+                    "{stage} scalar expr @{} uses field-vector formula without field-vector values",
+                    expr.symbol
+                )));
+            };
+            verify_count(
+                "field vector expr operands",
+                &expr.symbol,
+                1,
+                expr.operands.len(),
+            )?;
+            for operand in &expr.operands {
+                let VerifierScalarExprOperand::FieldVector(value_ref) = operand else {
+                    return Err(EmitError::new(format!(
+                        "{stage} scalar expr @{} expected field-vector operand @{}",
+                        expr.symbol,
+                        operand.symbol()
+                    )));
+                };
+                if !field_vector_values.contains_ref(value_ref) {
+                    return Err(EmitError::new(format!(
+                        "field vector expr @{} references missing field vector @{}",
+                        expr.symbol,
+                        value_ref.symbol()
+                    )));
+                }
+            }
+        }
+        ScalarExprKind::PowerStridedWeightedSum { .. } => {
+            for operand in &expr.operands {
+                let VerifierScalarExprOperand::Field(value_ref) = operand else {
+                    return Err(EmitError::new(format!(
+                        "{stage} scalar expr @{} expected field operand @{}",
+                        expr.symbol,
+                        operand.symbol()
+                    )));
+                };
+                if !field_values.contains_ref(value_ref) {
+                    return Err(EmitError::new(format!(
+                        "scalar expr @{} references missing field value @{}",
+                        expr.symbol,
+                        value_ref.symbol()
+                    )));
+                }
+            }
+        }
+        ScalarExprKind::StructuredPolynomial { .. } => {
+            verify_count(
+                "structured polynomial scalar expr operands",
+                &expr.symbol,
+                2,
+                expr.operands.len(),
+            )?;
+            for operand in &expr.operands {
+                let VerifierScalarExprOperand::Point(value_ref) = operand else {
+                    return Err(EmitError::new(format!(
+                        "{stage} scalar expr @{} expected point operand @{}",
+                        expr.symbol,
+                        operand.symbol()
+                    )));
+                };
+                if !point_values.is_some_and(|values| values.contains_ref(value_ref)) {
+                    return Err(EmitError::new(format!(
+                        "structured polynomial scalar expr @{} references missing point value @{}",
+                        expr.symbol,
+                        value_ref.symbol()
+                    )));
+                }
+            }
+        }
+        ScalarExprKind::PointElement { .. } => {
+            verify_count(
+                "point element scalar expr operands",
+                &expr.symbol,
+                1,
+                expr.operands.len(),
+            )?;
+            let Some(point_values) = point_values else {
+                return Err(EmitError::new(format!(
+                    "{stage} scalar expr @{} uses point element formula without point sources",
+                    expr.symbol
+                )));
+            };
+            for operand in &expr.operands {
+                let VerifierScalarExprOperand::Point(value_ref) = operand else {
+                    return Err(EmitError::new(format!(
+                        "{stage} scalar expr @{} expected point operand @{}",
+                        expr.symbol,
+                        operand.symbol()
+                    )));
+                };
+                if !point_values.contains_ref(value_ref) {
+                    return Err(EmitError::new(format!(
+                        "point element scalar expr @{} references missing point @{}",
+                        expr.symbol,
+                        value_ref.symbol()
+                    )));
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+pub(super) struct ScalarExprFlowVerification<'a> {
+    pub stage: &'static str,
+    pub cpu_exprs: &'a [CpuScalarExprPlan],
+    pub verifier_exprs: Option<&'a [VerifierScalarExprPlan]>,
+    pub field_values: &'a VerifierScalarSourceSet,
+    pub verifier_field_values: Option<&'a VerifierScalarValueSet>,
+    pub field_vector_values: Option<&'a VerifierFieldVectorValueSet>,
+    pub point_values: Option<&'a VerifierPointSourceSet>,
+    pub verifier_point_values: Option<&'a VerifierPointValueSet>,
+}
+
+pub(super) fn verify_scalar_expr_flow(
+    verification: ScalarExprFlowVerification<'_>,
+) -> Result<(), EmitError> {
+    let ScalarExprFlowVerification {
+        stage,
+        cpu_exprs,
+        verifier_exprs,
+        field_values,
+        verifier_field_values,
+        field_vector_values,
+        point_values,
+        verifier_point_values,
+    } = verification;
+    if let (Some(exprs), Some(field_values)) = (verifier_exprs, verifier_field_values) {
+        if let Some(point_values) = verifier_point_values {
+            point_values.verify_no_conflicts(stage)?;
+        }
+        for expr in exprs {
+            verify_verifier_scalar_expr_operands(VerifierScalarExprVerification {
+                stage,
+                expr,
+                field_values,
+                field_vector_values,
+                point_values: verifier_point_values,
+            })?;
+        }
+    } else {
+        for expr in cpu_exprs {
+            verify_scalar_expr_operands(ScalarExprVerification {
+                stage,
+                symbol: &expr.symbol,
+                formula: &expr.formula,
+                operand_names: &expr.operand_names,
+                operands: &expr.operands,
+                field_values,
+                field_vector_values,
+                point_values,
+            })?;
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn role_relation_kind_expr(
+    stage_type_prefix: &str,
+    role: &Role,
+    relation: &str,
+) -> Result<String, EmitError> {
+    if role == &Role::Prover {
+        return Ok(format!("{relation:?}"));
+    }
+    relation_kind_expr(stage_type_prefix, relation)
+}
+
+pub(super) fn role_sumcheck_point_order_expr(
+    role: &Role,
+    point_order: &str,
+) -> Result<String, EmitError> {
+    if role == &Role::Prover {
+        return Ok(format!("{point_order:?}"));
+    }
+    sumcheck_point_order_expr(point_order)
+}
+
+pub(super) fn role_optional_relation_kind_expr(
+    stage_type_prefix: &str,
+    role: &Role,
+    relation: Option<&str>,
+) -> Result<String, EmitError> {
+    relation
+        .map(|relation| role_relation_kind_expr(stage_type_prefix, role, relation))
+        .transpose()
+        .map(|relation| {
+            relation.map_or_else(|| "None".to_owned(), |relation| format!("Some({relation})"))
+        })
+}
+
+pub(super) fn role_opening_equality_mode_expr(
+    stage_type_prefix: &str,
+    role: &Role,
+    mode: &str,
+) -> Result<String, EmitError> {
+    if role == &Role::Prover {
+        return Ok(format!("{mode:?}"));
+    }
+    opening_equality_mode_expr(stage_type_prefix, mode)
+}
+
+fn program_step_kind_expr(stage_type_prefix: &str, kind: &str) -> Result<String, EmitError> {
+    let variant = ProgramStepKind::from_cpu_attr(kind)
+        .map_err(plan_error)?
+        .rust_variant();
+    Ok(format!("{stage_type_prefix}ProgramStepKind::{variant}"))
+}
+
+fn transcript_squeeze_kind_expr(stage_type_prefix: &str, kind: &str) -> Result<String, EmitError> {
+    let variant = TranscriptSqueezeKind::from_cpu_attr(kind)
+        .map_err(plan_error)?
+        .rust_variant();
+    Ok(format!(
+        "{stage_type_prefix}TranscriptSqueezeKind::{variant}"
+    ))
+}
+
+pub(super) fn claim_kind_expr(stage_type_prefix: &str, kind: &str) -> Result<String, EmitError> {
+    let variant = ClaimKind::from_cpu_attr(kind)
+        .map_err(plan_error)?
+        .rust_variant();
+    Ok(format!("{stage_type_prefix}ClaimKind::{variant}"))
+}
+
+fn relation_kind_expr(stage_type_prefix: &str, relation: &str) -> Result<String, EmitError> {
+    let variant = JoltVerifierRelationKind::from_cpu_attr(relation)
+        .map_err(plan_error)?
+        .rust_variant();
+    Ok(format!("{stage_type_prefix}RelationKind::{variant}"))
+}
+
+fn sumcheck_point_order_expr(point_order: &str) -> Result<String, EmitError> {
+    let variant = SumcheckPointOrder::from_cpu_attr(point_order)
+        .map_err(plan_error)?
+        .rust_variant();
+    Ok(format!(
+        "bolt_verifier_runtime::SumcheckPointOrder::{variant}"
+    ))
+}
+
+pub(super) fn pcs_proof_mode_expr(
+    stage_type_prefix: &str,
+    mode: &str,
+) -> Result<String, EmitError> {
+    let variant = PcsProofMode::from_cpu_attr(mode)
+        .map_err(plan_error)?
+        .rust_variant();
+    Ok(format!("{stage_type_prefix}PcsProofMode::{variant}"))
+}
+
+fn opening_equality_mode_expr(stage_type_prefix: &str, mode: &str) -> Result<String, EmitError> {
+    let variant = OpeningEqualityMode::from_cpu_attr(mode)
+        .map_err(plan_error)?
+        .rust_variant();
+    Ok(format!("{stage_type_prefix}OpeningEqualityMode::{variant}"))
+}
+
+fn plan_error(error: RustTargetPlanError) -> EmitError {
+    EmitError::new(error.to_string())
+}
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs
new file mode 100644
index 0000000000..52d4e5b0bf
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs
@@ -0,0 +1,58 @@
+use crate::emit::rust::{push_format, EmitError};
+use crate::ir::Role;
+use crate::protocols::jolt::verifier_relation_outputs::RelationOutputPlan;
+
+pub fn emit_verifier_relation_output_constants(
+    stage_type: &str,
+    _role: &Role,
+    relation_outputs: &[RelationOutputPlan],
+) -> Result<String, EmitError> {
+    let mut source = String::new();
+    let mut claims = Vec::new();
+    for (index, claim) in relation_outputs.iter().enumerate() {
+        let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim);
+        claims.push(format!(
+            "    {stage_type}RelationOutputPlan {{ relation: {}, local_scalars: {local_scalars}, expected_output: {} }},",
+            crate::protocols::jolt::verifier_plan::relation_kind_expr(stage_type, claim.relation()),
+            rust_str(claim.expected_output_symbol())
+        ));
+    }
+    let claims = claims.join("\n");
+    let claims_name = format!("{}_RELATION_OUTPUTS", stage_type.to_ascii_uppercase());
+    push_format(
+        &mut source,
+        format_args!(
+            "pub const {claims_name}: &[{stage_type}RelationOutputPlan] = &[\n{claims}\n];\n\n"
+        ),
+    );
+    Ok(source)
+}
+
+fn emit_local_scalar_constants(
+    source: &mut String,
+    stage_type: &str,
+    claim_index: usize,
+    claim: &RelationOutputPlan,
+) -> String {
+    if !claim.has_local_scalars() {
+        return "&[]".to_owned();
+    }
+    let name = format!(
+        "{}_RELATION_OUTPUT_{claim_index}_LOCAL_SCALARS",
+        stage_type.to_ascii_uppercase()
+    );
+    let scalars = claim
+        .local_scalar_symbols()
+        .map(|symbol| rust_str(symbol))
+        .collect::<Vec<_>>()
+        .join(", ");
+    push_format(
+        source,
+        format_args!("pub const {name}: &[&str] = &[{scalars}];\n"),
+    );
+    name
+}
+
+fn rust_str(value: &str) -> String {
+    format!("{value:?}")
+}
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs
index 9975b41010..c23c0ca74e 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs
@@ -709,25 +709,21 @@ impl Stage1CpuProgram {
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE1_PARAMS: Stage1Params = Stage1Params {{\n\
-             \x20   field: {},\n\
-             \x20   pcs: {},\n\
-             \x20   transcript: {},\n\
-             }};\n",
+                "pub const STAGE1_PARAMS: Stage1Params = Stage1Params {{ field: {}, pcs: {}, transcript: {} }};\n",
                 rust_str(&self.params.field),
                 rust_str(&self.params.pcs),
                 rust_str(&self.params.transcript)
             ),
         );
 
-        source.push_str(&self.emit_transcript_squeeze_constants());
+        source.push_str(&self.emit_transcript_squeeze_constants()?);
         source.push_str(&self.emit_kernel_constants());
         source.push_str(&self.emit_sumcheck_claim_constants()?);
         source.push_str(&self.emit_sumcheck_batch_constants());
         source.push_str(&self.emit_sumcheck_driver_constants()?);
-        source.push_str(&self.emit_sumcheck_instance_result_constants());
+        source.push_str(&self.emit_sumcheck_instance_result_constants()?);
         source.push_str(&self.emit_sumcheck_eval_constants());
-        source.push_str(&self.emit_opening_claim_constants());
+        source.push_str(&self.emit_opening_claim_constants()?);
         source.push_str(&self.emit_opening_batch_constants());
         source.push_str(
             "pub const STAGE1_PROGRAM: Stage1CpuProgramPlan = Stage1CpuProgramPlan {\n\
@@ -746,50 +742,61 @@ impl Stage1CpuProgram {
         Ok(source)
     }
 
-    fn emit_sumcheck_instance_result_constants(&self) -> String {
+    fn emit_sumcheck_instance_result_constants(&self) -> Result<String, EmitError> {
         let instances = self
             .instance_results
             .iter()
             .map(|instance| {
-                format!(
+                Ok(format!(
                     "    Stage1SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},",
                     rust_str(&instance.symbol),
                     rust_str(&instance.source),
                     rust_str(&instance.claim),
-                    rust_str(&instance.relation),
+                    super::plan_tokens::role_relation_kind_expr(
+                        "Stage1",
+                        &self.role,
+                        &instance.relation
+                    )?,
                     instance.index,
                     instance.point_arity,
                     instance.num_rounds,
                     instance.round_offset,
-                    rust_str(&instance.point_order),
+                    super::plan_tokens::role_sumcheck_point_order_expr(
+                        &self.role,
+                        &instance.point_order
+                    )?,
                     instance.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE1_SUMCHECK_INSTANCE_RESULTS: &[Stage1SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_transcript_squeeze_constants(&self) -> String {
+    fn emit_transcript_squeeze_constants(&self) -> Result<String, EmitError> {
         let squeezes = self
             .transcript_squeezes
             .iter()
             .map(|squeeze| {
-                format!(
+                Ok(format!(
                     "    Stage1TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},",
                     rust_str(&squeeze.symbol),
                     rust_str(&squeeze.label),
-                    rust_str(&squeeze.kind),
+                    super::plan_tokens::role_transcript_squeeze_kind_expr(
+                        "Stage1",
+                        &self.role,
+                        &squeeze.kind
+                    )?,
                     squeeze.count,
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE1_TRANSCRIPT_SQUEEZES: &[Stage1TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n"
-        )
+        ))
     }
 
     fn emit_kernel_constants(&self) -> String {
@@ -862,14 +869,13 @@ impl Stage1CpuProgram {
                 .enumerate()
                 .map(|(index, batch)| {
                     format!(
-                        "    Stage1SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE1_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
+                        "    Stage1SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE1_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
                         rust_str(&batch.symbol),
                         rust_str(&batch.stage),
                         rust_str(&batch.proof_slot),
                         rust_str(&batch.policy),
                         batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|")),
+                        super::plan_tokens::rust_str_slice_expr(&batch.claim_operands),
                         rust_str(&batch.claim_label),
                         rust_str(&batch.round_label)
                     )
@@ -984,25 +990,27 @@ impl Stage1CpuProgram {
         format!("pub const STAGE1_SUMCHECK_EVALS: &[Stage1SumcheckEvalPlan] = &[\n{evals}\n];\n\n")
     }
 
-    fn emit_opening_claim_constants(&self) -> String {
+    fn emit_opening_claim_constants(&self) -> Result<String, EmitError> {
         let claims = self
             .opening_claims
             .iter()
             .map(|claim| {
-                format!(
+                Ok(format!(
                     "    Stage1OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.oracle),
                     rust_str(&claim.domain),
                     claim.point_arity,
-                    rust_str(&claim.claim_kind),
+                    super::plan_tokens::role_claim_kind_expr("Stage1", &self.role, &claim.claim_kind)?,
                     rust_str(&claim.point_source),
                     rust_str(&claim.eval_source)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE1_OPENING_CLAIMS: &[Stage1OpeningClaimPlan] = &[\n{claims}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE1_OPENING_CLAIMS: &[Stage1OpeningClaimPlan] = &[\n{claims}\n];\n\n"
+        ))
     }
 
     fn emit_opening_batch_constants(&self) -> String {
@@ -1018,8 +1026,8 @@ impl Stage1CpuProgram {
                         rust_str(&batch.proof_slot),
                         rust_str(&batch.policy),
                         batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|"))
+                        super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims),
+                        super::plan_tokens::rust_str_slice_expr(&batch.claim_operands)
                     )
                 })
                 .collect::<Vec<_>>()
@@ -1066,7 +1074,7 @@ impl Stage1CpuProgram {
     }
 
     fn emit_verifier_imports() -> &'static str {
-        "use super::common::append_labeled_scalar;\n\
+        "use bolt_verifier_runtime::append_labeled_scalar;\n\
          use jolt_field::Fr;\n\
          use jolt_sumcheck::{CompressedLabeledRoundPoly, LabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier};\n\
          use jolt_transcript::{Blake2bTranscript, Transcript};"
@@ -1075,21 +1083,24 @@ impl Stage1CpuProgram {
     fn emit_verifier_types() -> &'static str {
         r"pub type DefaultStage1Transcript = Blake2bTranscript<Fr>;
 
-pub type Stage1Params = super::common::StageParams;
-pub type Stage1NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage1SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage1ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage1ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage1Proof<F> = super::common::StageProof<F>;
-pub type Stage1VerifierProgramPlan = super::common::VerifierProgramPlanMinimal;
-
-pub use super::common::{
-    OpeningBatchPlan as Stage1OpeningBatchPlan, OpeningClaimPlan as Stage1OpeningClaimPlan,
+pub type Stage1Params = bolt_verifier_runtime::StageParams;
+pub type Stage1NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage1SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage1ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage1ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage1Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage1VerifierProgramPlan = bolt_verifier_runtime::VerifierProgramPlanMinimal<Stage1RelationKind>;
+pub type Stage1SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage1RelationKind>;
+pub type Stage1SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage1RelationKind>;
+pub type Stage1SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage1RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage1RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage1ClaimKind, OpeningBatchPlan as Stage1OpeningBatchPlan,
+    OpeningClaimPlan as Stage1OpeningClaimPlan,
     SumcheckBatchPlan as Stage1SumcheckBatchPlan, SumcheckEvalPlan as Stage1SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage1SumcheckInstanceResultPlan,
+    TranscriptSqueezeKind as Stage1TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage1TranscriptSqueezePlan,
-    SumcheckClaimPlan as Stage1SumcheckClaimPlan,
-    SumcheckDriverPlan as Stage1SumcheckDriverPlan,
 };
 
 #[derive(Debug)]
@@ -1100,7 +1111,7 @@ pub enum VerifyStage1Error {
     MissingClaim { driver: &'static str, claim: &'static str },
     MissingDependency { driver: &'static str, dependency: &'static str },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage1RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 "
@@ -1111,24 +1122,20 @@ pub enum VerifyStage1Error {
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE1_PARAMS: Stage1Params = Stage1Params {{\n\
-             \x20   field: {},\n\
-             \x20   pcs: {},\n\
-             \x20   transcript: {},\n\
-             }};\n",
+                "pub const STAGE1_PARAMS: Stage1Params = Stage1Params {{ field: {}, pcs: {}, transcript: {} }};\n",
                 rust_str(&self.params.field),
                 rust_str(&self.params.pcs),
                 rust_str(&self.params.transcript)
             ),
         );
 
-        source.push_str(&self.emit_transcript_squeeze_constants());
+        source.push_str(&self.emit_transcript_squeeze_constants()?);
         source.push_str(&self.emit_verifier_sumcheck_claim_constants()?);
         source.push_str(&self.emit_sumcheck_batch_constants());
         source.push_str(&self.emit_verifier_sumcheck_driver_constants()?);
-        source.push_str(&self.emit_sumcheck_instance_result_constants());
+        source.push_str(&self.emit_sumcheck_instance_result_constants()?);
         source.push_str(&self.emit_sumcheck_eval_constants());
-        source.push_str(&self.emit_opening_claim_constants());
+        source.push_str(&self.emit_opening_claim_constants()?);
         source.push_str(&self.emit_opening_batch_constants());
         source.push_str(
             "pub const STAGE1_PROGRAM: Stage1VerifierProgramPlan = Stage1VerifierProgramPlan {\n\
@@ -1154,16 +1161,19 @@ pub enum VerifyStage1Error {
                 .as_deref()
                 .ok_or_else(|| missing_role_binding("verifier claim relation", &claim.symbol))?;
             claims.push(format!(
-                    "    Stage1SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {}, input_openings: {} }},",
+                    "    Stage1SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {} }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.stage),
                     rust_str(&claim.domain),
                     claim.num_rounds,
                     claim.degree,
                     rust_str(&claim.claim),
-                    rust_str(relation),
-                    rust_str(&claim.claim_value),
-                    rust_str(&claim.input_openings.join("|"))
+                    super::plan_tokens::role_relation_kind_expr(
+                        "Stage1",
+                        &self.role,
+                        relation
+                    )?,
+                    rust_str(&claim.claim_value)
                 ));
         }
         let claims = claims.join("\n");
@@ -1191,7 +1201,11 @@ pub enum VerifyStage1Error {
                     rust_str(&driver.symbol),
                     rust_str(&driver.stage),
                     rust_str(&driver.proof_slot),
-                    rust_str(relation),
+                    super::plan_tokens::role_relation_kind_expr(
+                        "Stage1",
+                        &self.role,
+                        relation
+                    )?,
                     rust_str(&driver.batch),
                     rust_str(&driver.policy),
                     rust_str(&driver.claim_label),
@@ -1307,10 +1321,17 @@ where
             reason: "driver symbol mismatch",
         });
     }
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage1Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     match relation {
-        "jolt.stage1.outer.uniskip" => verify_outer_uniskip(program, driver, proof, transcript),
-        "jolt.stage1.outer.remaining" => {
+        Stage1RelationKind::Stage1OuterUniskip => {
+            verify_outer_uniskip(program, driver, proof, transcript)
+        }
+        Stage1RelationKind::Stage1OuterRemaining => {
             verify_outer_remaining(program, driver, proof, completed, transcript)
         }
         relation => Err(VerifyStage1Error::UnsupportedRelation { relation }),
@@ -1497,10 +1518,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String {
 fn emit_usize_array(name: &str, values: &[usize]) -> String {
     let entries = values
         .iter()
-        .map(|value| format!("    {value},"))
+        .map(usize::to_string)
         .collect::<Vec<_>>()
-        .join("\n");
-    format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n")
+        .join(", ");
+    format!("pub const {name}: &[usize] = &[{entries}];\n\n")
 }
 
 fn rust_str(value: &str) -> String {
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs
index b7c3f61d63..25e4e0469d 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs
@@ -6,27 +6,63 @@ use melior::ir::{Attribute, OperationRef};
 
 use crate::emit::rust::{push_format, EmitError, RustSourceFile};
 use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role};
+use crate::protocols::jolt::rust_target_plan::{
+    structured_polynomial_scalar_formula, JoltVerifierRelationKind,
+};
+use crate::protocols::jolt::verifier_opening_rows;
+use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan};
+use crate::protocols::jolt::verifier_point_rows;
+use crate::protocols::jolt::verifier_program_rows;
+use crate::protocols::jolt::verifier_relation_outputs::{
+    self, StructuredPolynomialEvalPlan as Stage2StructuredPolynomialEvalPlan,
+};
+use crate::protocols::jolt::verifier_sumcheck_rows;
+use crate::protocols::jolt::verifier_value_rows;
+use crate::protocols::jolt::verifier_values;
 use crate::schema::verify_cpu_schema;
 
+type Stage2RelationOutputPlan = verifier_relation_outputs::RelationOutputPlan;
+type Stage2TranscriptSqueezePlan = verifier_program_rows::CpuTranscriptSqueezePlan;
+type Stage2ProgramStepPlan = verifier_program_rows::CpuProgramStepPlan;
+type Stage2OpeningInputPlan = verifier_program_rows::CpuOpeningInputPlan;
+type Stage2FieldConstantPlan = verifier_value_rows::CpuFieldConstantPlan;
+type Stage2FieldExprPlan = verifier_value_rows::CpuFieldExprPlan;
+type Stage2ScalarExprPlan = verifier_value_rows::CpuScalarExprPlan;
+type Stage2SumcheckClaimPlan = verifier_sumcheck_rows::CpuSumcheckClaimPlan;
+type Stage2SumcheckBatchPlan = verifier_sumcheck_rows::CpuSumcheckBatchPlan;
+type Stage2SumcheckDriverPlan = verifier_sumcheck_rows::CpuSumcheckDriverPlan;
+type Stage2SumcheckInstanceResultPlan = verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan;
+type Stage2SumcheckEvalPlan = verifier_sumcheck_rows::CpuSumcheckEvalPlan;
+type Stage2PointSlicePlan = verifier_point_rows::CpuPointSlicePlan;
+type Stage2PointConcatPlan = verifier_point_rows::CpuPointConcatPlan;
+type Stage2OpeningClaimPlan = verifier_opening_rows::CpuOpeningClaimPlan;
+type Stage2OpeningClaimEqualityPlan = verifier_opening_rows::CpuOpeningClaimEqualityPlan;
+type Stage2OpeningBatchPlan = verifier_opening_rows::CpuOpeningBatchPlan;
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Stage2CpuProgram {
     pub role: Role,
+    pub(crate) verifier_plan: Option<VerifierStagePlan>,
     pub params: Stage2Params,
     pub steps: Vec<Stage2ProgramStepPlan>,
     pub transcript_squeezes: Vec<Stage2TranscriptSqueezePlan>,
     pub opening_inputs: Vec<Stage2OpeningInputPlan>,
     pub field_constants: Vec<Stage2FieldConstantPlan>,
     pub field_exprs: Vec<Stage2FieldExprPlan>,
+    pub scalar_exprs: Vec<Stage2ScalarExprPlan>,
     pub kernels: Vec<Stage2KernelPlan>,
     pub claims: Vec<Stage2SumcheckClaimPlan>,
     pub batches: Vec<Stage2SumcheckBatchPlan>,
     pub drivers: Vec<Stage2SumcheckDriverPlan>,
     pub instance_results: Vec<Stage2SumcheckInstanceResultPlan>,
     pub evals: Vec<Stage2SumcheckEvalPlan>,
+    pub relation_outputs: Vec<Stage2RelationOutputPlan>,
     pub point_slices: Vec<Stage2PointSlicePlan>,
     pub point_concats: Vec<Stage2PointConcatPlan>,
     pub opening_claims: Vec<Stage2OpeningClaimPlan>,
+    pub opening_equalities: Vec<Stage2OpeningClaimEqualityPlan>,
     pub opening_batches: Vec<Stage2OpeningBatchPlan>,
+    pub relation_output_values: Vec<Stage2StructuredPolynomialEvalPlan>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -46,151 +82,355 @@ pub struct Stage2KernelPlan {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2TranscriptSqueezePlan {
-    pub symbol: String,
-    pub label: String,
-    pub kind: String,
-    pub count: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2ProgramStepPlan {
-    pub kind: String,
-    pub symbol: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2OpeningInputPlan {
-    pub symbol: String,
-    pub source_stage: String,
-    pub source_claim: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2FieldConstantPlan {
-    pub symbol: String,
-    pub field: String,
-    pub value: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2FieldExprPlan {
-    pub symbol: String,
-    pub kind: String,
-    pub formula: String,
-    pub operand_names: Vec<String>,
-    pub operands: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2SumcheckClaimPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub domain: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-    pub claim: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub claim_value: String,
-    pub input_openings: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2SumcheckBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub round_schedule: Vec<usize>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2SumcheckDriverPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub batch: String,
-    pub policy: String,
-    pub round_schedule: Vec<usize>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2SumcheckInstanceResultPlan {
-    pub symbol: String,
-    pub source: String,
-    pub claim: String,
-    pub relation: String,
-    pub index: usize,
-    pub point_arity: usize,
-    pub num_rounds: usize,
-    pub round_offset: usize,
-    pub point_order: String,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2SumcheckEvalPlan {
-    pub symbol: String,
-    pub source: String,
-    pub name: String,
-    pub index: usize,
-    pub oracle: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2PointSlicePlan {
-    pub symbol: String,
-    pub source: String,
-    pub offset: usize,
-    pub length: usize,
-    pub input: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2PointConcatPlan {
-    pub symbol: String,
-    pub layout: String,
-    pub arity: usize,
-    pub inputs: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2OpeningClaimPlan {
-    pub symbol: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-    pub point_source: String,
-    pub eval_source: String,
+struct Stage2RelationOutputRows {
+    field_constants: Vec<Stage2FieldConstantPlan>,
+    field_exprs: Vec<Stage2FieldExprPlan>,
+    scalar_exprs: Vec<Stage2ScalarExprPlan>,
+    relation_outputs: Vec<Stage2RelationOutputPlan>,
+}
+
+fn stage2_field_expr(
+    symbol: &str,
+    formula: &str,
+    operands: impl IntoIterator<Item = &'static str>,
+) -> Stage2FieldExprPlan {
+    let operands = operands.into_iter().map(str::to_owned).collect::<Vec<_>>();
+    Stage2FieldExprPlan {
+        symbol: symbol.to_owned(),
+        kind: "op".to_owned(),
+        formula: formula.to_owned(),
+        operand_names: operands.clone(),
+        operands,
+    }
+}
+
+fn stage2_scalar_expr(
+    symbol: &str,
+    formula: String,
+    operands: impl IntoIterator<Item = &'static str>,
+) -> Stage2ScalarExprPlan {
+    let operands = operands.into_iter().map(str::to_owned).collect::<Vec<_>>();
+    Stage2ScalarExprPlan {
+        symbol: symbol.to_owned(),
+        kind: "op".to_owned(),
+        formula,
+        operand_names: operands.clone(),
+        operands,
+    }
+}
+
+fn stage2_relation_output_plans() -> Stage2RelationOutputRows {
+    Stage2RelationOutputRows {
+        field_constants: vec![Stage2FieldConstantPlan {
+            symbol: "stage2.product_virtual.remainder.one".to_owned(),
+            field: "bn254_fr".to_owned(),
+            value: 1,
+        }],
+        scalar_exprs: vec![
+            stage2_scalar_expr(
+                "stage2.ram_read_write.output.eq.Cycle",
+                structured_polynomial_scalar_formula(
+                    "eq", "prefix", "y_point", "reverse", "full", "full", "as_is",
+                ),
+                [
+                    "stage2.ram_read_write.instance",
+                    "stage2.input.stage1.RamReadValue",
+                ],
+            ),
+            stage2_scalar_expr(
+                "stage2.instruction_lookup.output.eq.LookupOutput",
+                structured_polynomial_scalar_formula(
+                    "eq", "full", "full", "reverse", "full", "full", "as_is",
+                ),
+                [
+                    "stage2.instruction_lookup.claim_reduction.instance",
+                    "stage2.input.stage1.LookupOutput",
+                ],
+            ),
+            stage2_scalar_expr(
+                "stage2.product_virtual.remainder.point.UniskipR0",
+                "point.element:0".to_owned(),
+                ["stage2.product_virtual.uniskip.sumcheck"],
+            ),
+            stage2_scalar_expr(
+                "stage2.product_virtual.remainder.output.eq.Product",
+                structured_polynomial_scalar_formula(
+                    "eq", "full", "full", "reverse", "full", "full", "as_is",
+                ),
+                [
+                    "stage2.product_virtual.remainder.instance",
+                    "stage2.input.stage1.Product",
+                ],
+            ),
+        ],
+        field_exprs: vec![
+            stage2_field_expr(
+                "stage2.ram_read_write.output.partial.ValPlusInc",
+                "field.add",
+                [
+                    "stage2.ram_read_write.eval.RamVal",
+                    "stage2.ram_read_write.eval.RamInc",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.ram_read_write.output.term.GammaValPlusInc",
+                "field.mul",
+                [
+                    "stage2.ram_read_write.gamma",
+                    "stage2.ram_read_write.output.partial.ValPlusInc",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.ram_read_write.output.partial.WeightedVal",
+                "field.add",
+                [
+                    "stage2.ram_read_write.eval.RamVal",
+                    "stage2.ram_read_write.output.term.GammaValPlusInc",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.ram_read_write.output.claim_expr",
+                "field.product",
+                [
+                    "stage2.ram_read_write.output.eq.Cycle",
+                    "stage2.ram_read_write.eval.RamRa",
+                    "stage2.ram_read_write.output.partial.WeightedVal",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.instruction_lookup.output.term.LeftLookupOperand",
+                "field.mul",
+                [
+                    "stage2.instruction_lookup.gamma",
+                    "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.instruction_lookup.output.term.RightLookupOperand",
+                "field.mul",
+                [
+                    "stage2.instruction_lookup.gamma2",
+                    "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.instruction_lookup.output.term.LeftInstructionInput",
+                "field.mul",
+                [
+                    "stage2.instruction_lookup.gamma3",
+                    "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.instruction_lookup.output.term.RightInstructionInput",
+                "field.mul",
+                [
+                    "stage2.instruction_lookup.gamma4",
+                    "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.instruction_lookup.output.partial.LookupOutputLeftOperand",
+                "field.add",
+                [
+                    "stage2.instruction_lookup.claim_reduction.eval.LookupOutput",
+                    "stage2.instruction_lookup.output.term.LeftLookupOperand",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.instruction_lookup.output.partial.RightOperand",
+                "field.add",
+                [
+                    "stage2.instruction_lookup.output.partial.LookupOutputLeftOperand",
+                    "stage2.instruction_lookup.output.term.RightLookupOperand",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.instruction_lookup.output.partial.LeftInstructionInput",
+                "field.add",
+                [
+                    "stage2.instruction_lookup.output.partial.RightOperand",
+                    "stage2.instruction_lookup.output.term.LeftInstructionInput",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.instruction_lookup.output.weighted_expr",
+                "field.add",
+                [
+                    "stage2.instruction_lookup.output.partial.LeftInstructionInput",
+                    "stage2.instruction_lookup.output.term.RightInstructionInput",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.instruction_lookup.output.claim_expr",
+                "field.mul",
+                [
+                    "stage2.instruction_lookup.output.eq.LookupOutput",
+                    "stage2.instruction_lookup.output.weighted_expr",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.high",
+                "poly.lagrange_kernel_eval:-1:3",
+                [
+                    "stage2.product_virtual.tau_high",
+                    "stage2.product_virtual.remainder.point.UniskipR0",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.weight.Product",
+                "poly.lagrange_basis_eval:-1:3:0",
+                ["stage2.product_virtual.remainder.point.UniskipR0"],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.weight.ShouldBranch",
+                "poly.lagrange_basis_eval:-1:3:1",
+                ["stage2.product_virtual.remainder.point.UniskipR0"],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.weight.ShouldJump",
+                "poly.lagrange_basis_eval:-1:3:2",
+                ["stage2.product_virtual.remainder.point.UniskipR0"],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.left.LeftInstructionInput",
+                "field.mul",
+                [
+                    "stage2.product_virtual.remainder.output.weight.Product",
+                    "stage2.product_virtual.remainder.eval.LeftInstructionInput",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.left.LookupOutput",
+                "field.mul",
+                [
+                    "stage2.product_virtual.remainder.output.weight.ShouldBranch",
+                    "stage2.product_virtual.remainder.eval.LookupOutput",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.left.OpFlagJump",
+                "field.mul",
+                [
+                    "stage2.product_virtual.remainder.output.weight.ShouldJump",
+                    "stage2.product_virtual.remainder.eval.OpFlagJump",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.left.weighted_expr",
+                "field.sum",
+                [
+                    "stage2.product_virtual.remainder.output.left.LeftInstructionInput",
+                    "stage2.product_virtual.remainder.output.left.LookupOutput",
+                    "stage2.product_virtual.remainder.output.left.OpFlagJump",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.right.RightInstructionInput",
+                "field.mul",
+                [
+                    "stage2.product_virtual.remainder.output.weight.Product",
+                    "stage2.product_virtual.remainder.eval.RightInstructionInput",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.right.InstructionFlagBranch",
+                "field.mul",
+                [
+                    "stage2.product_virtual.remainder.output.weight.ShouldBranch",
+                    "stage2.product_virtual.remainder.eval.InstructionFlagBranch",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.partial.NotNextIsNoop",
+                "field.sub",
+                [
+                    "stage2.product_virtual.remainder.one",
+                    "stage2.product_virtual.remainder.eval.NextIsNoop",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.right.NextIsNoop",
+                "field.mul",
+                [
+                    "stage2.product_virtual.remainder.output.weight.ShouldJump",
+                    "stage2.product_virtual.remainder.output.partial.NotNextIsNoop",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.right.weighted_expr",
+                "field.sum",
+                [
+                    "stage2.product_virtual.remainder.output.right.RightInstructionInput",
+                    "stage2.product_virtual.remainder.output.right.InstructionFlagBranch",
+                    "stage2.product_virtual.remainder.output.right.NextIsNoop",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.product_virtual.remainder.output.claim_expr",
+                "field.product",
+                [
+                    "stage2.product_virtual.remainder.output.high",
+                    "stage2.product_virtual.remainder.output.eq.Product",
+                    "stage2.product_virtual.remainder.output.left.weighted_expr",
+                    "stage2.product_virtual.remainder.output.right.weighted_expr",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.ram_raf.output.claim_expr",
+                "field.mul",
+                ["stage2.ram_raf.output.unmap", "stage2.ram_raf.eval.RamRa"],
+            ),
+            stage2_field_expr(
+                "stage2.ram_output.output.partial.ValFinalMinusIo",
+                "field.sub",
+                [
+                    "stage2.ram_output.eval.RamValFinal",
+                    "stage2.ram_output.output.val_io",
+                ],
+            ),
+            stage2_field_expr(
+                "stage2.ram_output.output.claim_expr",
+                "field.product",
+                [
+                    "stage2.ram_output.output.eq",
+                    "stage2.ram_output.output.io_mask",
+                    "stage2.ram_output.output.partial.ValFinalMinusIo",
+                ],
+            ),
+        ],
+        relation_outputs: vec![
+            Stage2RelationOutputPlan::new(
+                JoltVerifierRelationKind::Stage2RamReadWrite,
+                "stage2.ram_read_write.output.claim_expr",
+            ),
+            Stage2RelationOutputPlan::new(
+                JoltVerifierRelationKind::Stage2InstructionLookupClaimReduction,
+                "stage2.instruction_lookup.output.claim_expr",
+            ),
+            Stage2RelationOutputPlan::new(
+                JoltVerifierRelationKind::Stage2ProductVirtualRemainder,
+                "stage2.product_virtual.remainder.output.claim_expr",
+            ),
+            Stage2RelationOutputPlan::with_local_scalars(
+                JoltVerifierRelationKind::Stage2RamRafEvaluation,
+                ["stage2.ram_raf.output.unmap".to_owned()],
+                "stage2.ram_raf.output.claim_expr",
+            ),
+            Stage2RelationOutputPlan::with_local_scalars(
+                JoltVerifierRelationKind::Stage2RamOutputCheck,
+                [
+                    "stage2.ram_output.output.eq".to_owned(),
+                    "stage2.ram_output.output.io_mask".to_owned(),
+                    "stage2.ram_output.output.val_io".to_owned(),
+                ],
+                "stage2.ram_output.output.claim_expr",
+            ),
+        ],
+    }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage2OpeningBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-}
+verifier_plan::impl_verifier_plan_source_traits!(program = Stage2CpuProgram,);
 
 pub fn stage2_cpu_program(module: &BoltModule<'_, Cpu>) -> Result<Stage2CpuProgram, EmitError> {
     verify_cpu_schema(module)?;
@@ -216,16 +456,20 @@ impl Stage2CpuProgram {
         let mut opening_inputs = Vec::new();
         let mut field_constants = Vec::new();
         let mut field_exprs = Vec::new();
+        let mut scalar_exprs = Vec::new();
         let mut kernels = Vec::new();
         let mut claims = Vec::new();
         let mut batches = Vec::new();
         let mut drivers = Vec::new();
         let mut instance_results = Vec::new();
         let mut evals = Vec::new();
+        let mut relation_outputs = Vec::new();
         let mut point_slices = Vec::new();
         let mut point_concats = Vec::new();
         let mut opening_claims = Vec::new();
+        let opening_equalities = Vec::new();
         let mut opening_batches = Vec::new();
+        let relation_output_values = Vec::new();
 
         let mut operation = module.as_mlir_module().body().first_operation();
         while let Some(op) = operation {
@@ -478,27 +722,56 @@ impl Stage2CpuProgram {
             }
         }
 
-        Ok(Self {
+        let role = module
+            .role()
+            .ok_or_else(|| EmitError::new("missing cpu party role"))?;
+        let is_verifier = role == Role::Verifier;
+        if is_verifier {
+            let relation_output_rows = stage2_relation_output_plans();
+            field_constants.extend(relation_output_rows.field_constants);
+            field_exprs.extend(relation_output_rows.field_exprs);
+            scalar_exprs.extend(relation_output_rows.scalar_exprs);
+            relation_outputs.extend(relation_output_rows.relation_outputs);
+        }
+
+        let mut program = Self {
             params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?,
-            role: module
-                .role()
-                .ok_or_else(|| EmitError::new("missing cpu party role"))?,
+            role,
+            verifier_plan: None,
             steps,
             transcript_squeezes,
             opening_inputs,
             field_constants,
             field_exprs,
+            scalar_exprs,
             kernels,
             claims,
             batches,
             drivers,
             instance_results,
             evals,
+            relation_outputs,
             point_slices,
             point_concats,
             opening_claims,
+            opening_equalities,
             opening_batches,
-        })
+            relation_output_values,
+        };
+        if is_verifier {
+            program.verifier_plan = Some(program.plan_verifier()?);
+        }
+        Ok(program)
+    }
+
+    fn plan_verifier(&self) -> Result<VerifierStagePlan, EmitError> {
+        verifier_plan::plan_verifier_stage_from_cpu_sources(self)
+    }
+
+    fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> {
+        self.verifier_plan
+            .as_ref()
+            .ok_or_else(|| EmitError::new("missing stage2 verifier plan"))
     }
 
     fn verify_supported_target(&self) -> Result<(), EmitError> {
@@ -513,7 +786,11 @@ impl Stage2CpuProgram {
                 self.verify_kernel_definitions()?;
                 self.verify_prover_driver_bindings()?;
             }
-            Role::Verifier => self.verify_verifier_driver_bindings()?,
+            Role::Verifier => {
+                self.verifier_plan()?.verify_sumcheck_flow("stage2")?;
+                self.verify_verifier_driver_bindings()?;
+                self.verify_relation_outputs()?;
+            }
         }
         self.verify_opening_flow()
     }
@@ -560,6 +837,28 @@ impl Stage2CpuProgram {
                 }
             }
         }
+        if self.role == Role::Verifier {
+            let field_values = self.verifier_scalar_values();
+            let verifier_point_values = self.verifier_point_values();
+            field_values.verify_no_conflicts("stage2")?;
+            verifier_point_values.verify_no_conflicts("stage2")?;
+            for expr in &self.scalar_exprs {
+                let expr = verifier_plan::VerifierScalarExprPlan::from_cpu(
+                    &expr.symbol,
+                    &expr.formula,
+                    &expr.operands,
+                )?;
+                super::plan_tokens::verify_verifier_scalar_expr_operands(
+                    super::plan_tokens::VerifierScalarExprVerification {
+                        stage: "stage2",
+                        expr: &expr,
+                        field_values: &field_values,
+                        field_vector_values: None,
+                        point_values: Some(&verifier_point_values),
+                    },
+                )?;
+            }
+        }
         for claim in &self.claims {
             if !field_values.contains(&claim.claim_value) {
                 return Err(EmitError::new(format!(
@@ -583,10 +882,106 @@ impl Stage2CpuProgram {
                 .map(|squeeze| &squeeze.symbol),
         ));
         values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol)));
+        values.extend(symbols(self.scalar_exprs.iter().map(|expr| &expr.symbol)));
+        values.extend(symbols(
+            self.relation_outputs
+                .iter()
+                .flat_map(|output| output.local_scalar_symbols()),
+        ));
         values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol)));
         values
     }
 
+    fn verifier_scalar_values(&self) -> verifier_values::VerifierScalarValueSet {
+        let mut values = verifier_values::VerifierScalarValueSet::default();
+        for input in &self.opening_inputs {
+            values.insert(
+                &input.symbol,
+                verifier_values::VerifierScalarValueKind::OpeningInput,
+            );
+        }
+        for constant in &self.field_constants {
+            values.insert(
+                &constant.symbol,
+                verifier_values::VerifierScalarValueKind::FieldConstant,
+            );
+        }
+        for squeeze in self
+            .transcript_squeezes
+            .iter()
+            .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar"))
+        {
+            values.insert(
+                &squeeze.symbol,
+                verifier_values::VerifierScalarValueKind::TranscriptScalar,
+            );
+        }
+        for expr in &self.field_exprs {
+            values.insert(
+                &expr.symbol,
+                verifier_values::VerifierScalarValueKind::FieldExpr,
+            );
+        }
+        for expr in &self.scalar_exprs {
+            values.insert(
+                &expr.symbol,
+                verifier_values::VerifierScalarValueKind::ScalarExpr,
+            );
+        }
+        for local_scalar in self
+            .relation_outputs
+            .iter()
+            .flat_map(|output| output.local_scalar_symbols())
+        {
+            values.insert(
+                local_scalar,
+                verifier_values::VerifierScalarValueKind::RelationOutputLocal,
+            );
+        }
+        for eval in &self.evals {
+            values.insert(
+                &eval.symbol,
+                verifier_values::VerifierScalarValueKind::SumcheckEval,
+            );
+        }
+        values
+    }
+
+    fn verifier_point_values(&self) -> verifier_values::VerifierPointValueSet {
+        let mut values = verifier_values::VerifierPointValueSet::default();
+        for input in &self.opening_inputs {
+            values.insert(
+                &input.symbol,
+                verifier_values::VerifierPointValueKind::OpeningInput,
+            );
+        }
+        for driver in &self.drivers {
+            values.insert(
+                &driver.symbol,
+                verifier_values::VerifierPointValueKind::SumcheckInstance,
+            );
+        }
+        for instance in &self.instance_results {
+            values.insert(
+                &instance.symbol,
+                verifier_values::VerifierPointValueKind::SumcheckInstance,
+            );
+        }
+        for slice in &self.point_slices {
+            values.insert(
+                &slice.symbol,
+                verifier_values::VerifierPointValueKind::PointExpr,
+            );
+        }
+        for concat in &self.point_concats {
+            values.insert(
+                &concat.symbol,
+                verifier_values::VerifierPointValueKind::PointExpr,
+            );
+        }
+        values
+    }
+
     fn verify_kernel_definitions(&self) -> Result<(), EmitError> {
         for kernel in &self.kernels {
             if kernel.backend != "cpu" {
@@ -723,11 +1118,6 @@ impl Stage2CpuProgram {
                 "verifier stage2 program must not contain kernels",
             ));
         }
-        let batches: BTreeMap<_, _> = self
-            .batches
-            .iter()
-            .map(|batch| (batch.symbol.as_str(), batch))
-            .collect();
         for claim in &self.claims {
             if claim.kernel.is_some() || claim.relation.is_none() {
                 return Err(EmitError::new(format!(
@@ -743,29 +1133,18 @@ impl Stage2CpuProgram {
                     driver.symbol
                 )));
             }
-            let batch = batches.get(driver.batch.as_str()).ok_or_else(|| {
-                EmitError::new(format!(
-                    "sumcheck driver @{} references missing batch @{}",
-                    driver.symbol, driver.batch
-                ))
-            })?;
-            verify_count(
-                "sumcheck driver round_schedule",
-                &driver.symbol,
-                driver.num_rounds,
-                driver.round_schedule.iter().sum(),
-            )?;
-            if driver.round_schedule != batch.round_schedule {
-                return Err(EmitError::new(format!(
-                    "sumcheck driver @{} round_schedule differs from batch @{}",
-                    driver.symbol, batch.symbol
-                )));
-            }
         }
         Ok(())
     }
 
+    fn verify_relation_outputs(&self) -> Result<(), EmitError> {
+        self.verifier_plan()?.verify_relation_outputs("stage2")
+    }
+
     fn verify_opening_flow(&self) -> Result<(), EmitError> {
+        if self.role == Role::Verifier {
+            return self.verifier_plan()?.verify_opening_flow("stage2");
+        }
         let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol));
         point_sources.extend(symbols(
             self.instance_results
@@ -926,10 +1305,9 @@ impl Stage2CpuProgram {
     }
 
     fn emit_verifier_imports() -> &'static str {
-        "use super::common::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, pow_field, require_operand_count, reverse_slice, single_operand};\n\
-         use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt, RingCore};\n\
-         use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval};\n\
-         use jolt_poly::{EqPolynomial, UnivariatePoly};\n\
+        "use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, find_batch, find_plan, reverse_slice};\n\
+         use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt};\n\
+         use jolt_poly::UnivariatePoly;\n\
          use jolt_sumcheck::{CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier};\n\
          use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};"
     }
@@ -937,25 +1315,34 @@ impl Stage2CpuProgram {
     fn emit_verifier_types() -> &'static str {
         r"pub type DefaultStage2Transcript = Blake2bTranscript<Fr>;
 
-pub type Stage2NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage2SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage2ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage2ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage2Proof<F> = super::common::StageProof<F>;
-pub type Stage2OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-pub type Stage2VerifierProgramPlan = super::common::StageVerifierProgramPlanNoEqualities;
-
-pub use super::common::{
-    FieldConstantPlan as Stage2FieldConstantPlan, FieldExprPlan as Stage2FieldExprPlan,
+pub type Stage2NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage2SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage2ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage2ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage2Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage2OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage2VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlan<Stage2RelationKind>;
+pub type Stage2SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage2RelationKind>;
+pub type Stage2SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage2RelationKind>;
+pub type Stage2SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage2RelationKind>;
+pub type Stage2RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage2RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage2RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan,
+    FieldExprKind as Stage2FieldExprKind,
+    FieldExprPlan as Stage2FieldExprPlan,
+    OpeningClaimEqualityPlan as Stage2OpeningClaimEqualityPlan,
+    ScalarExprPlan as Stage2ScalarExprPlan,
+    ScalarExprKind as Stage2ScalarExprKind,
     OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan,
-    OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan,
-    PointSlicePlan as Stage2PointSlicePlan, ProgramStepPlan as Stage2ProgramStepPlan,
-    StageParams as Stage2Params, SumcheckBatchPlan as Stage2SumcheckBatchPlan,
+    OpeningInputPlan as Stage2OpeningInputPlan, PointExprKind as Stage2PointExprKind,
+    PointExprPlan as Stage2PointExprPlan, ProgramStepKind as Stage2ProgramStepKind,
+    ProgramStepPlan as Stage2ProgramStepPlan, StageParams as Stage2Params,
+    SumcheckBatchPlan as Stage2SumcheckBatchPlan,
     SumcheckEvalPlan as Stage2SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage2SumcheckInstanceResultPlan,
+    TranscriptSqueezeKind as Stage2TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage2TranscriptSqueezePlan,
-    SumcheckClaimPlan as Stage2SumcheckClaimPlan,
-    SumcheckDriverPlan as Stage2SumcheckDriverPlan,
 };
 
 #[derive(Clone, Copy, Debug)]
@@ -982,7 +1369,7 @@ pub struct Stage2RamData<'a> {
 }
 
 #[derive(Clone, Debug, Default)]
-struct Stage2ValueStore<F: Field>(super::common::ValueStore<F>);
+struct Stage2ValueStore<F: Field>(bolt_verifier_runtime::ValueStore<F>);
 
 #[derive(Debug)]
 pub enum VerifyStage2Error {
@@ -993,23 +1380,22 @@ pub enum VerifyStage2Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
-    MissingRam { relation: &'static str },
+    UnsupportedRelation { relation: Stage2RelationKind },
+    MissingRam { context: &'static str },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error);
 "
     }
 
     fn emit_prover_constants(&self) -> Result<String, EmitError> {
-        let mut source = self.emit_shared_constants();
+        let mut source = self.emit_shared_constants()?;
         source.push_str(&self.emit_kernel_constants());
         source.push_str(&self.emit_prover_sumcheck_claim_constants()?);
         source.push_str(&self.emit_sumcheck_batch_constants());
         source.push_str(&self.emit_prover_sumcheck_driver_constants()?);
-        source.push_str(&self.emit_tail_constants());
+        source.push_str(&self.emit_tail_constants()?);
         source.push_str(
             "pub const STAGE2_PROGRAM: Stage2CpuProgramPlan = Stage2CpuProgramPlan {\n\
              \x20   params: STAGE2_PARAMS,\n\
@@ -1034,11 +1420,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
     }
 
     fn emit_verifier_constants(&self) -> Result<String, EmitError> {
-        let mut source = self.emit_shared_constants();
+        let mut source = self.emit_shared_constants()?;
         source.push_str(&self.emit_verifier_sumcheck_claim_constants()?);
         source.push_str(&self.emit_sumcheck_batch_constants());
         source.push_str(&self.emit_verifier_sumcheck_driver_constants()?);
-        source.push_str(&self.emit_tail_constants());
+        source.push_str(&self.emit_tail_constants()?);
+        source.push_str(&self.emit_verifier_relation_output_constants()?);
         source.push_str(
             "pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan {\n\
              \x20   params: STAGE2_PARAMS,\n\
@@ -1047,85 +1434,102 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
              \x20   opening_inputs: STAGE2_OPENING_INPUTS,\n\
              \x20   field_constants: STAGE2_FIELD_CONSTANTS,\n\
              \x20   field_exprs: STAGE2_FIELD_EXPRS,\n\
+             \x20   scalar_exprs: STAGE2_SCALAR_EXPRS,\n\
              \x20   claims: STAGE2_SUMCHECK_CLAIMS,\n\
              \x20   batches: STAGE2_SUMCHECK_BATCHES,\n\
              \x20   drivers: STAGE2_SUMCHECK_DRIVERS,\n\
              \x20   instance_results: STAGE2_SUMCHECK_INSTANCE_RESULTS,\n\
              \x20   evals: STAGE2_SUMCHECK_EVALS,\n\
-             \x20   point_slices: STAGE2_POINT_SLICES,\n\
-             \x20   point_concats: STAGE2_POINT_CONCATS,\n\
+             \x20   relation_outputs: STAGE2_RELATION_OUTPUTS,\n\
+             \x20   point_exprs: STAGE2_POINT_EXPRS,\n\
              \x20   opening_claims: STAGE2_OPENING_CLAIMS,\n\
+             \x20   opening_equalities: STAGE2_OPENING_EQUALITIES,\n\
              \x20   opening_batches: STAGE2_OPENING_BATCHES,\n\
              };\n",
         );
         Ok(source)
     }
 
-    fn emit_shared_constants(&self) -> String {
+    fn emit_verifier_relation_output_constants(&self) -> Result<String, EmitError> {
+        super::relation_outputs::emit_verifier_relation_output_constants(
+            "Stage2",
+            &self.role,
+            &self.relation_outputs,
+        )
+    }
+
+    fn emit_shared_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE2_PARAMS: Stage2Params = Stage2Params {{\n\
-             \x20   field: {},\n\
-             \x20   pcs: {},\n\
-             \x20   transcript: {},\n\
-             }};\n",
+                "pub const STAGE2_PARAMS: Stage2Params = Stage2Params {{ field: {}, pcs: {}, transcript: {} }};\n",
                 rust_str(&self.params.field),
                 rust_str(&self.params.pcs),
                 rust_str(&self.params.transcript)
             ),
         );
-        source.push_str(&self.emit_program_step_constants());
-        source.push_str(&self.emit_transcript_squeeze_constants());
-        source.push_str(&self.emit_opening_input_constants());
+        source.push_str(&self.emit_program_step_constants()?);
+        source.push_str(&self.emit_transcript_squeeze_constants()?);
+        source.push_str(&self.emit_opening_input_constants()?);
         source.push_str(&self.emit_field_constant_constants());
-        source.push_str(&self.emit_field_expr_constants());
-        source
+        source.push_str(&self.emit_field_expr_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_scalar_expr_constants()?);
+        }
+        Ok(source)
     }
 
-    fn emit_program_step_constants(&self) -> String {
+    fn emit_program_step_constants(&self) -> Result<String, EmitError> {
         let steps = self
             .steps
             .iter()
             .map(|step| {
-                format!(
+                Ok(format!(
                     "    Stage2ProgramStepPlan {{ kind: {}, symbol: {} }},",
-                    rust_str(&step.kind),
+                    super::plan_tokens::role_program_step_kind_expr(
+                        "Stage2", &self.role, &step.kind
+                    )?,
                     rust_str(&step.symbol),
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE2_PROGRAM_STEPS: &[Stage2ProgramStepPlan] = &[\n{steps}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE2_PROGRAM_STEPS: &[Stage2ProgramStepPlan] = &[\n{steps}\n];\n\n"
+        ))
     }
 
-    fn emit_transcript_squeeze_constants(&self) -> String {
+    fn emit_transcript_squeeze_constants(&self) -> Result<String, EmitError> {
         let squeezes = self
             .transcript_squeezes
             .iter()
             .map(|squeeze| {
-                format!(
+                Ok(format!(
                     "    Stage2TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},",
                     rust_str(&squeeze.symbol),
                     rust_str(&squeeze.label),
-                    rust_str(&squeeze.kind),
+                    super::plan_tokens::role_transcript_squeeze_kind_expr(
+                        "Stage2",
+                        &self.role,
+                        &squeeze.kind
+                    )?,
                     squeeze.count,
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE2_TRANSCRIPT_SQUEEZES: &[Stage2TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_opening_input_constants(&self) -> String {
+    fn emit_opening_input_constants(&self) -> Result<String, EmitError> {
         let inputs = self
             .opening_inputs
             .iter()
             .map(|input| {
-                format!(
+                Ok(format!(
                     "    Stage2OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},",
                     rust_str(&input.symbol),
                     rust_str(&input.source_stage),
@@ -1133,12 +1537,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
                     rust_str(&input.oracle),
                     rust_str(&input.domain),
                     input.point_arity,
-                    rust_str(&input.claim_kind)
-                )
+                    super::plan_tokens::role_claim_kind_expr("Stage2", &self.role, &input.claim_kind)?
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE2_OPENING_INPUTS: &[Stage2OpeningInputPlan] = &[\n{inputs}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE2_OPENING_INPUTS: &[Stage2OpeningInputPlan] = &[\n{inputs}\n];\n\n"
+        ))
     }
 
     fn emit_field_constant_constants(&self) -> String {
@@ -1160,25 +1566,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
         )
     }
 
-    fn emit_field_expr_constants(&self) -> String {
+    fn emit_field_expr_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let exprs = self
-                .field_exprs
-                .iter()
-                .map(|expr| {
-                    format!(
-                        "    Stage2FieldExprPlan {{ symbol: {}, kind: {}, formula: {}, operands: {} }},",
-                        rust_str(&expr.symbol),
-                        rust_str(&expr.kind),
-                        rust_str(&expr.formula),
-                        rust_str(&expr.operands.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[\n{exprs}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_field_expr_constants(
+                "Stage2",
+                "STAGE2",
+                &plan.field_exprs,
+            ));
         }
 
         let mut source = String::new();
@@ -1220,7 +1615,16 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
                 "pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[\n{exprs}\n];\n"
             ),
         );
-        source
+        Ok(source)
+    }
+
+    fn emit_scalar_expr_constants(&self) -> Result<String, EmitError> {
+        let plan = self.verifier_plan()?;
+        Ok(verifier_plan::emit_scalar_expr_constants(
+            "Stage2",
+            "STAGE2",
+            &plan.scalar_exprs,
+        ))
     }
 
     fn emit_kernel_constants(&self) -> String {
@@ -1283,16 +1687,19 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
                     missing_role_binding("verifier claim relation", &claim.symbol)
                 })?;
                 claims.push(format!(
-                        "    Stage2SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {}, input_openings: {} }},",
+                        "    Stage2SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {} }},",
                         rust_str(&claim.symbol),
                         rust_str(&claim.stage),
                         rust_str(&claim.domain),
                         claim.num_rounds,
                         claim.degree,
                         rust_str(&claim.claim),
-                        rust_str(relation),
-                        rust_str(&claim.claim_value),
-                        rust_str(&claim.input_openings.join("|"))
+                        super::plan_tokens::role_relation_kind_expr(
+                            "Stage2",
+                            &self.role,
+                            relation
+                        )?,
+                        rust_str(&claim.claim_value)
                     ));
             }
         }
@@ -1321,14 +1728,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
                 .enumerate()
                 .map(|(index, batch)| {
                     format!(
-                        "    Stage2SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE2_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
+                        "    Stage2SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE2_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
                         rust_str(&batch.symbol),
                         rust_str(&batch.stage),
                         rust_str(&batch.proof_slot),
                         rust_str(&batch.policy),
                         batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|")),
+                        super::plan_tokens::rust_str_slice_expr(&batch.claim_operands),
                         rust_str(&batch.claim_label),
                         rust_str(&batch.round_label)
                     )
@@ -1431,7 +1837,11 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
                         rust_str(&driver.symbol),
                         rust_str(&driver.stage),
                         rust_str(&driver.proof_slot),
-                        rust_str(relation),
+                        super::plan_tokens::role_relation_kind_expr(
+                            "Stage2",
+                            &self.role,
+                            relation
+                        )?,
                         rust_str(&driver.batch),
                         rust_str(&driver.policy),
                         rust_str(&driver.claim_label),
@@ -1451,41 +1861,52 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
         Ok(source)
     }
 
-    fn emit_tail_constants(&self) -> String {
+    fn emit_tail_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
-        source.push_str(&self.emit_sumcheck_instance_result_constants());
+        source.push_str(&self.emit_sumcheck_instance_result_constants()?);
         source.push_str(&self.emit_sumcheck_eval_constants());
-        source.push_str(&self.emit_point_slice_constants());
-        source.push_str(&self.emit_point_concat_constants());
-        source.push_str(&self.emit_opening_claim_constants());
+        source.push_str(&self.emit_point_expr_constants()?);
+        source.push_str(&self.emit_opening_claim_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(
+                "pub const STAGE2_OPENING_EQUALITIES: &[Stage2OpeningClaimEqualityPlan] = &[];\n",
+            );
+        }
         source.push_str(&self.emit_opening_batch_constants());
-        source
+        Ok(source)
     }
 
-    fn emit_sumcheck_instance_result_constants(&self) -> String {
+    fn emit_sumcheck_instance_result_constants(&self) -> Result<String, EmitError> {
         let instances = self
             .instance_results
             .iter()
             .map(|instance| {
-                format!(
+                Ok(format!(
                     "    Stage2SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},",
                     rust_str(&instance.symbol),
                     rust_str(&instance.source),
                     rust_str(&instance.claim),
-                    rust_str(&instance.relation),
+                    super::plan_tokens::role_relation_kind_expr(
+                        "Stage2",
+                        &self.role,
+                        &instance.relation
+                    )?,
                     instance.index,
                     instance.point_arity,
                     instance.num_rounds,
                     instance.round_offset,
-                    rust_str(&instance.point_order),
+                    super::plan_tokens::role_sumcheck_point_order_expr(
+                        &self.role,
+                        &instance.point_order
+                    )?,
                     instance.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE2_SUMCHECK_INSTANCE_RESULTS: &[Stage2SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n"
-        )
+        ))
     }
 
     fn emit_sumcheck_eval_constants(&self) -> String {
@@ -1507,7 +1928,18 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
         format!("pub const STAGE2_SUMCHECK_EVALS: &[Stage2SumcheckEvalPlan] = &[\n{evals}\n];\n\n")
     }
 
-    fn emit_point_slice_constants(&self) -> String {
+    fn emit_point_expr_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let point_exprs =
+                verifier_plan::point_exprs_from_cpu(&self.point_slices, &self.point_concats);
+            return Ok(verifier_plan::emit_point_expr_constants(
+                "Stage2",
+                "STAGE2",
+                &point_exprs,
+            ));
+        }
+
+        let mut source = String::new();
         let slices = self
             .point_slices
             .iter()
@@ -1523,31 +1955,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!("pub const STAGE2_POINT_SLICES: &[Stage2PointSlicePlan] = &[\n{slices}\n];\n\n")
-    }
-
-    fn emit_point_concat_constants(&self) -> String {
-        if self.role == Role::Verifier {
-            let concats = self
-                .point_concats
-                .iter()
-                .map(|concat| {
-                    format!(
-                        "    Stage2PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},",
-                        rust_str(&concat.symbol),
-                        rust_str(&concat.layout),
-                        concat.arity,
-                        rust_str(&concat.inputs.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE2_POINT_CONCATS: &[Stage2PointConcatPlan] = &[\n{concats}\n];\n"
-            );
-        }
-
-        let mut source = String::new();
+        push_format(
+            &mut source,
+            format_args!(
+                "pub const STAGE2_POINT_SLICES: &[Stage2PointSlicePlan] = &[\n{slices}\n];\n\n"
+            ),
+        );
         for (index, concat) in self.point_concats.iter().enumerate() {
             source.push_str(&emit_str_array(
                 &format!("STAGE2_POINT_CONCAT_{index}_INPUTS"),
@@ -1574,28 +1987,30 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
                 "pub const STAGE2_POINT_CONCATS: &[Stage2PointConcatPlan] = &[\n{concats}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_opening_claim_constants(&self) -> String {
+    fn emit_opening_claim_constants(&self) -> Result<String, EmitError> {
         let claims = self
             .opening_claims
             .iter()
             .map(|claim| {
-                format!(
+                Ok(format!(
                     "    Stage2OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.oracle),
                     rust_str(&claim.domain),
                     claim.point_arity,
-                    rust_str(&claim.claim_kind),
+                    super::plan_tokens::role_claim_kind_expr("Stage2", &self.role, &claim.claim_kind)?,
                     rust_str(&claim.point_source),
                     rust_str(&claim.eval_source)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[\n{claims}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[\n{claims}\n];\n\n"
+        ))
     }
 
     fn emit_opening_batch_constants(&self) -> String {
@@ -1611,8 +2026,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
                         rust_str(&batch.proof_slot),
                         rust_str(&batch.policy),
                         batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|"))
+                        super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims),
+                        super::plan_tokens::rust_str_slice_expr(&batch.claim_operands)
                     )
                 })
                 .collect::<Vec<_>>()
@@ -1728,19 +2143,19 @@ where
     } else {
         for step in program.steps {
             match step.kind {
-                "transcript_squeeze" => {
+                Stage2ProgramStepKind::TranscriptSqueeze => {
                     let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage2Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                     verify_stage2_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
                 }
-                "sumcheck_driver" => {
+                Stage2ProgramStepKind::SumcheckDriver => {
                     let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage2Error::MissingProof {
                         driver: step.symbol,
                     })?;
                     verify_stage2_driver(program, driver, proof, ram, &mut store, transcript, &mut artifacts)?;
                 }
-                _ => {
+                Stage2ProgramStepKind::TranscriptAbsorbBytes => {
                     return Err(VerifyStage2Error::InvalidProof {
                         driver: step.symbol,
                         reason: "unsupported stage2 program step",
@@ -1803,12 +2218,19 @@ where
         .ok_or(VerifyStage2Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage2Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage2.product_virtual.uniskip" => {
+        Stage2RelationKind::Stage2ProductVirtualUniskip => {
             verify_product_virtual_uniskip(program, driver, proof, store, transcript)?
         }
-        "jolt.stage2.batched" => verify_batched_stage2(program, driver, proof, ram, store, transcript)?,
+        Stage2RelationKind::Stage2Batched => {
+            verify_batched_stage2(program, driver, proof, ram, store, transcript)?
+        }
         relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
@@ -1919,8 +2341,21 @@ where
             reason: "batched point mismatch",
         });
     }
-    let expected =
-        expected_batched_output_claim(program, driver, &*store, &proof.evals, &output.point, &batching_coeffs, ram)?;
+    let expected = bolt_verifier_runtime::evaluate_relation_output_batch(
+        driver,
+        program.batches,
+        program.claims,
+        program.instance_results,
+        program.relation_outputs,
+        program.field_exprs,
+        program.scalar_exprs,
+        &[],
+        &store.0,
+        &proof.evals,
+        &output.point,
+        &batching_coeffs,
+        |instance, _, local_point| stage2_relation_output_inputs(&*store, ram, instance, local_point),
+    )?;
     if output.value != expected {
         return Err(VerifyStage2Error::InvalidProof {
             driver: driver.symbol,
@@ -1934,7 +2369,7 @@ where
         proof: proof.proof.clone(),
     };
     store.observe_sumcheck_output(program, &verified)?;
-    super::common::append_opening_claims(
+    bolt_verifier_runtime::append_opening_claims(
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
@@ -1952,7 +2387,7 @@ impl<F: Field> Stage2ValueStore<F> {
         program: &'static Stage2VerifierProgramPlan,
         inputs: &[Stage2OpeningInputValue<F>],
     ) -> Result<Self, VerifyStage2Error> {
-        Ok(Self(super::common::ValueStore::with_opening_inputs(
+        Ok(Self(bolt_verifier_runtime::ValueStore::with_opening_inputs(
             inputs,
             program.opening_inputs,
         )?))
@@ -1986,16 +2421,16 @@ impl<F: Field> Stage2ValueStore<F> {
             program.evals,
             output,
             |instance, mut point| {
-                match instance.point_order {
-                    "as_is" => {}
-                    "reverse" => point.reverse(),
-                    _ => {
-                        return Err(VerifyStage2Error::InvalidProof {
-                            driver: output.driver,
-                            reason: "unsupported point order",
-                        });
-                    }
+            match instance.point_order {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
+                    return Err(VerifyStage2Error::InvalidProof {
+                        driver: output.driver,
+                        reason: "unsupported relation-local point order",
+                    });
                 }
+            }
                 Ok(point)
             },
             |input, expected, actual| VerifyStage2Error::InvalidInputLength {
@@ -2024,7 +2459,10 @@ impl<F: Field> Stage2ValueStore<F> {
         program: &'static Stage2VerifierProgramPlan,
         batch: &Stage2SumcheckBatchPlan,
     ) -> Result<Vec<F>, VerifyStage2Error> {
-        super::common::symbol_list(batch.claim_operands)
+        batch
+            .claim_operands
+            .iter()
+            .copied()
             .map(|symbol| {
                 let claim = find_plan(program.claims, symbol).ok_or(VerifyStage2Error::MissingClaim {
                     batch: batch.symbol,
@@ -2040,8 +2478,7 @@ impl<F: Field> Stage2ValueStore<F> {
         program: &'static Stage2VerifierProgramPlan,
     ) -> Result<(), VerifyStage2Error> {
         self.0.evaluate_available_points(
-            program.point_slices,
-            program.point_concats,
+            program.point_exprs,
             |input, expected, actual| VerifyStage2Error::InvalidInputLength {
                 input,
                 expected,
@@ -2055,7 +2492,8 @@ impl<F: Field> Stage2ValueStore<F> {
         program: &'static Stage2VerifierProgramPlan,
     ) -> Result<(), VerifyStage2Error> {
         self.0
-            .evaluate_available_field_exprs(program.field_exprs, evaluate_stage2_field_expr)
+            .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
+            .map_err(VerifyStage2Error::from)
     }
 
     fn scalar(&self, symbol: &'static str) -> Result<F, VerifyStage2Error> {
@@ -2073,276 +2511,58 @@ impl<F: Field> Stage2ValueStore<F> {
     }
 }
 
-fn evaluate_stage2_field_expr<F: Field>(
-    expr: &Stage2FieldExprPlan,
-    operands: &[F],
-) -> Result<F, VerifyStage2Error> {
-    match expr.formula {
-        "opening_eval" => Ok(single_operand(expr.symbol, operands)?),
-        "jolt_stage2_product_virtual_uniskip_input" => {
-            require_operand_count(expr.symbol, 4, operands.len())?;
-            let weights = lagrange_evals(
-                PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START,
-                PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE,
-                operands[0],
-            );
-            Ok(weights[0] * operands[1] + weights[1] * operands[2] + weights[2] * operands[3])
-        }
-        "jolt_stage2_ram_read_write_input" => {
-            require_operand_count(expr.symbol, 3, operands.len())?;
-            Ok(operands[1] + operands[0] * operands[2])
-        }
-        "jolt_stage2_instruction_lookup_input" => {
-            require_operand_count(expr.symbol, 6, operands.len())?;
-            let gamma = operands[0];
-            let gamma2 = gamma.square();
-            let gamma3 = gamma2 * gamma;
-            let gamma4 = gamma2.square();
-            Ok(operands[1]
-                + gamma * operands[2]
-                + gamma2 * operands[3]
-                + gamma3 * operands[4]
-                + gamma4 * operands[5])
-        }
-        "field.add" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] + operands[1])
-        }
-        "field.sub" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] - operands[1])
-        }
-        "field.mul" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] * operands[1])
-        }
-        "field.neg" => {
-            require_operand_count(expr.symbol, 1, operands.len())?;
-            Ok(-operands[0])
-        }
-        formula => {
-            if let Some(exponent) = formula.strip_prefix("field.pow:") {
-                require_operand_count(expr.symbol, 1, operands.len())?;
-                let exponent = exponent.parse::<usize>().map_err(|_| {
-                    VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                return Ok(pow_field(operands[0], exponent));
-            }
-            if let Some(spec) = formula.strip_prefix("poly.lagrange_basis_eval:") {
-                require_operand_count(expr.symbol, 1, operands.len())?;
-                let parts = spec.split(':').collect::<Vec<_>>();
-                if parts.len() != 3 {
-                    return Err(VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    });
-                }
-                let domain_start = parts[0].parse::<i64>().map_err(|_| {
-                    VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                let domain_size = parts[1].parse::<usize>().map_err(|_| {
-                    VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                let index = parts[2].parse::<usize>().map_err(|_| {
-                    VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                let weights = lagrange_evals(domain_start, domain_size, operands[0]);
-                return weights
-                    .get(index)
-                    .copied()
-                    .ok_or(VerifyStage2Error::InvalidInputLength {
-                        input: expr.symbol,
-                        expected: index + 1,
-                        actual: weights.len(),
-                    });
-            }
-            Err(VerifyStage2Error::UnsupportedFieldExpr {
-                symbol: expr.symbol,
-                formula,
-            })
-        }
-    }
-}
-
-fn expected_batched_output_claim(
-    program: &'static Stage2VerifierProgramPlan,
-    driver: &'static Stage2SumcheckDriverPlan,
+fn stage2_relation_output_inputs<'a>(
     store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
     ram: Option<&Stage2RamData<'_>>,
-) -> Result<Fr, VerifyStage2Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage2Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage2Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let value = match instance.relation {
-            "jolt.stage2.ram.read_write" => expected_ram_read_write(store, evals, local_point)?,
-            "jolt.stage2.product_virtual.remainder" => {
-                expected_product_remainder(store, evals, local_point)?
-            }
-            "jolt.stage2.instruction_lookup.claim_reduction" => {
-                expected_instruction_lookup(store, evals, local_point)?
-            }
-            "jolt.stage2.ram.raf_evaluation" => expected_ram_raf(evals, local_point, ram)?,
-            "jolt.stage2.ram.output_check" => expected_ram_output(store, evals, local_point, ram)?,
-            relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_ram_read_write(
-    store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage2Error> {
-    let r_cycle_stage1 = store.point("stage2.input.stage1.RamReadValue")?;
-    let log_t = r_cycle_stage1.len();
-    let r_cycle = reverse_slice(&local_point[..log_t]);
-    let eq_eval = EqPolynomial::<Fr>::mle(r_cycle_stage1, &r_cycle);
-    let gamma = store.scalar("stage2.ram_read_write.gamma")?;
-    let val = eval_by_name(evals, "stage2.ram_read_write.eval.RamVal")?;
-    let ra = eval_by_name(evals, "stage2.ram_read_write.eval.RamRa")?;
-    let inc = eval_by_name(evals, "stage2.ram_read_write.eval.RamInc")?;
-    Ok(eq_eval * ra * (val + gamma * (val + inc)))
-}
-
-fn expected_product_remainder(
-    store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage2Error> {
-    let tau_low = store.point("stage2.input.stage1.Product")?;
-    let tau_high = store.scalar("stage2.product_virtual.tau_high")?;
-    let r0 = *store
-        .point("stage2.product_virtual.uniskip.sumcheck")?
-        .first()
-        .ok_or(VerifyStage2Error::MissingValue {
-            symbol: "stage2.product_virtual.uniskip.sumcheck",
-        })?;
-    let r_tail = reverse_slice(local_point);
-    let low = EqPolynomial::<Fr>::mle(tau_low, &r_tail);
-    let high = lagrange_kernel_eval(
-        PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START,
-        PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE,
-        tau_high,
-        r0,
-    );
-    let weights = lagrange_evals(
-        PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START,
-        PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE,
-        r0,
-    );
-    let left = weights[0]
-        * eval_by_name(evals, "stage2.product_virtual.remainder.eval.LeftInstructionInput")?
-        + weights[1] * eval_by_name(evals, "stage2.product_virtual.remainder.eval.LookupOutput")?
-        + weights[2] * eval_by_name(evals, "stage2.product_virtual.remainder.eval.OpFlagJump")?;
-    let right = weights[0]
-        * eval_by_name(evals, "stage2.product_virtual.remainder.eval.RightInstructionInput")?
-        + weights[1]
-            * eval_by_name(evals, "stage2.product_virtual.remainder.eval.InstructionFlagBranch")?
-        + weights[2]
-            * (Fr::from_u64(1)
-                - eval_by_name(evals, "stage2.product_virtual.remainder.eval.NextIsNoop")?);
-    Ok(high * low * left * right)
-}
-
-fn expected_instruction_lookup(
-    store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage2Error> {
-    let opening_point = reverse_slice(local_point);
-    let r_spartan = store.point("stage2.input.stage1.LookupOutput")?;
-    let eq_eval = EqPolynomial::<Fr>::mle(&opening_point, r_spartan);
-    let gamma = store.scalar("stage2.instruction_lookup.gamma")?;
-    let gamma2 = gamma.square();
-    let gamma3 = gamma2 * gamma;
-    let gamma4 = gamma2.square();
-    let weighted = eval_by_name(
-        evals,
-        "stage2.instruction_lookup.claim_reduction.eval.LookupOutput",
-    )? + gamma
-        * eval_by_name(
-            evals,
-            "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand",
-        )?
-        + gamma2
-            * eval_by_name(
-                evals,
-                "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand",
-            )?
-        + gamma3
-            * eval_by_name(
-                evals,
-                "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput",
-            )?
-        + gamma4
-            * eval_by_name(
-                evals,
-                "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput",
-            )?;
-    Ok(eq_eval * weighted)
+    instance: &Stage2SumcheckInstanceResultPlan,
+    local_point: &'a [Fr],
+) -> Result<bolt_verifier_runtime::RelationOutputInputs<'a, Fr>, VerifyStage2Error> {
+    let scalars = match instance.relation {
+        Stage2RelationKind::Stage2RamRafEvaluation => stage2_ram_raf_output_scalars(local_point, ram)?,
+        Stage2RelationKind::Stage2RamOutputCheck => stage2_ram_output_scalars(store, local_point, ram)?,
+        _ => Vec::new(),
+    };
+    Ok(bolt_verifier_runtime::RelationOutputInputs {
+        scalars,
+        points: Vec::new(),
+    })
 }
 
-fn expected_ram_raf(
-    evals: &[Stage2NamedEval<Fr>],
+fn stage2_ram_raf_output_scalars(
     local_point: &[Fr],
     ram: Option<&Stage2RamData<'_>>,
-) -> Result<Fr, VerifyStage2Error> {
+) -> Result<Vec<bolt_verifier_runtime::NamedScalar<Fr>>, VerifyStage2Error> {
     let ram = ram.ok_or(VerifyStage2Error::MissingRam {
-        relation: "jolt.stage2.ram.raf_evaluation",
+        context: "stage2.ram.raf_evaluation",
     })?;
     let address = reverse_slice(local_point);
-    let unmap = unmap_eval(ram.log_k, ram.start_address, &address);
-    Ok(unmap * eval_by_name(evals, "stage2.ram_raf.eval.RamRa")?)
+    Ok(vec![bolt_verifier_runtime::NamedScalar {
+        symbol: "stage2.ram_raf.output.unmap",
+        value: unmap_eval(ram.log_k, ram.start_address, &address),
+    }])
 }
 
-fn expected_ram_output(
+fn stage2_ram_output_scalars(
     store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
     local_point: &[Fr],
     ram: Option<&Stage2RamData<'_>>,
-) -> Result<Fr, VerifyStage2Error> {
+) -> Result<Vec<bolt_verifier_runtime::NamedScalar<Fr>>, VerifyStage2Error> {
     let ram = ram.ok_or(VerifyStage2Error::MissingRam {
-        relation: "jolt.stage2.ram.output_check",
+        context: "stage2.ram.output_check",
     })?;
     let layout = ram.output_layout.ok_or(VerifyStage2Error::MissingRam {
-        relation: "jolt.stage2.ram.output_check.layout",
+        context: "stage2.ram.output_check.layout",
     })?;
     let r_address = store.point("stage2.ram_output.r_address")?;
     let opening_point = reverse_slice(local_point);
-    let eq_eval = EqPolynomial::<Fr>::mle(r_address, &opening_point);
+    if r_address.len() != opening_point.len() {
+        return Err(VerifyStage2Error::InvalidInputLength {
+            input: "stage2.ram_output.r_address",
+            expected: opening_point.len(),
+            actual: r_address.len(),
+        });
+    }
+    let eq_eval = eq_eval(r_address, &opening_point);
     let io_mask = range_mask_eval(layout.io_start, layout.io_end, &opening_point);
     let val_io = sparse_final_ram_eval(
         ram.final_ram,
@@ -2350,8 +2570,26 @@ fn expected_ram_output(
         layout.io_end,
         &opening_point,
     );
-    let val_final = eval_by_name(evals, "stage2.ram_output.eval.RamValFinal")?;
-    Ok(eq_eval * io_mask * (val_final - val_io))
+    Ok(vec![
+        bolt_verifier_runtime::NamedScalar {
+            symbol: "stage2.ram_output.output.eq",
+            value: eq_eval,
+        },
+        bolt_verifier_runtime::NamedScalar {
+            symbol: "stage2.ram_output.output.io_mask",
+            value: io_mask,
+        },
+        bolt_verifier_runtime::NamedScalar {
+            symbol: "stage2.ram_output.output.val_io",
+            value: val_io,
+        },
+    ])
+}
+
+fn eq_eval(lhs: &[Fr], rhs: &[Fr]) -> Fr {
+    lhs.iter().zip(rhs).fold(Fr::from_u64(1), |acc, (lhs, rhs)| {
+        acc * (*lhs * *rhs + (Fr::from_u64(1) - *lhs) * (Fr::from_u64(1) - *rhs))
+    })
 }
 
 fn driver_evals(
@@ -2521,10 +2759,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String {
 fn emit_usize_array(name: &str, values: &[usize]) -> String {
     let entries = values
         .iter()
-        .map(|value| format!("    {value},"))
+        .map(usize::to_string)
         .collect::<Vec<_>>()
-        .join("\n");
-    format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n")
+        .join(", ");
+    format!("pub const {name}: &[usize] = &[{entries}];\n\n")
 }
 
 fn intern_str_array(
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs
index 936557f08a..4f10f22bcd 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs
@@ -1,33 +1,52 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use melior::ir::block::BlockLike;
-use melior::ir::operation::{OperationLike, OperationResult};
-use melior::ir::{Attribute, OperationRef};
+use melior::ir::operation::OperationLike;
 
 use crate::emit::rust::{push_format, EmitError, RustSourceFile};
-use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role};
+use crate::ir::{BoltModule, Cpu, Role};
+use crate::protocols::jolt::cpu_attrs::{
+    operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr,
+};
+use crate::protocols::jolt::verifier_opening_rows;
+use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan};
+use crate::protocols::jolt::verifier_point_rows;
+use crate::protocols::jolt::verifier_program_rows;
+use crate::protocols::jolt::verifier_relation_outputs::{
+    self, RelationOutputAst as Stage3RelationOutputAst,
+    RelationOutputFieldExprPlan as Stage3RelationOutputFieldExprPlan,
+    RelationOutputPlan as Stage3RelationOutputPlan,
+    StructuredPolynomialEvalPlan as Stage3StructuredPolynomialEvalPlan,
+};
+use crate::protocols::jolt::verifier_sumcheck_rows;
+use crate::protocols::jolt::verifier_value_rows;
+use crate::protocols::jolt::verifier_values;
 use crate::schema::verify_cpu_schema;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Stage3CpuProgram {
     pub role: Role,
+    pub(crate) verifier_plan: Option<VerifierStagePlan>,
     pub params: Stage3Params,
-    pub steps: Vec<Stage3ProgramStepPlan>,
-    pub transcript_squeezes: Vec<Stage3TranscriptSqueezePlan>,
-    pub opening_inputs: Vec<Stage3OpeningInputPlan>,
-    pub field_constants: Vec<Stage3FieldConstantPlan>,
-    pub field_exprs: Vec<Stage3FieldExprPlan>,
+    pub steps: Vec<verifier_program_rows::CpuProgramStepPlan>,
+    pub transcript_squeezes: Vec<verifier_program_rows::CpuTranscriptSqueezePlan>,
+    pub opening_inputs: Vec<verifier_program_rows::CpuOpeningInputPlan>,
+    pub field_constants: Vec<verifier_value_rows::CpuFieldConstantPlan>,
+    pub field_exprs: Vec<verifier_value_rows::CpuFieldExprPlan>,
+    pub scalar_exprs: Vec<verifier_value_rows::CpuScalarExprPlan>,
     pub kernels: Vec<Stage3KernelPlan>,
-    pub claims: Vec<Stage3SumcheckClaimPlan>,
-    pub batches: Vec<Stage3SumcheckBatchPlan>,
-    pub drivers: Vec<Stage3SumcheckDriverPlan>,
-    pub instance_results: Vec<Stage3SumcheckInstanceResultPlan>,
-    pub evals: Vec<Stage3SumcheckEvalPlan>,
-    pub point_slices: Vec<Stage3PointSlicePlan>,
-    pub point_concats: Vec<Stage3PointConcatPlan>,
-    pub opening_claims: Vec<Stage3OpeningClaimPlan>,
-    pub opening_equalities: Vec<Stage3OpeningClaimEqualityPlan>,
-    pub opening_batches: Vec<Stage3OpeningBatchPlan>,
+    pub claims: Vec<verifier_sumcheck_rows::CpuSumcheckClaimPlan>,
+    pub batches: Vec<verifier_sumcheck_rows::CpuSumcheckBatchPlan>,
+    pub drivers: Vec<verifier_sumcheck_rows::CpuSumcheckDriverPlan>,
+    pub instance_results: Vec<verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan>,
+    pub evals: Vec<verifier_sumcheck_rows::CpuSumcheckEvalPlan>,
+    pub relation_output_values: Vec<Stage3StructuredPolynomialEvalPlan>,
+    pub relation_outputs: Vec<Stage3RelationOutputPlan>,
+    pub point_slices: Vec<verifier_point_rows::CpuPointSlicePlan>,
+    pub point_concats: Vec<verifier_point_rows::CpuPointConcatPlan>,
+    pub opening_claims: Vec<verifier_opening_rows::CpuOpeningClaimPlan>,
+    pub opening_equalities: Vec<verifier_opening_rows::CpuOpeningClaimEqualityPlan>,
+    pub opening_batches: Vec<verifier_opening_rows::CpuOpeningBatchPlan>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -46,160 +65,13 @@ pub struct Stage3KernelPlan {
     pub abi: String,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3TranscriptSqueezePlan {
-    pub symbol: String,
-    pub label: String,
-    pub kind: String,
-    pub count: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3ProgramStepPlan {
-    pub kind: String,
-    pub symbol: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3OpeningInputPlan {
-    pub symbol: String,
-    pub source_stage: String,
-    pub source_claim: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3FieldConstantPlan {
-    pub symbol: String,
-    pub field: String,
-    pub value: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3FieldExprPlan {
-    pub symbol: String,
-    pub kind: String,
-    pub formula: String,
-    pub operand_names: Vec<String>,
-    pub operands: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3SumcheckClaimPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub domain: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-    pub claim: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub claim_value: String,
-    pub input_openings: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3SumcheckBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub round_schedule: Vec<usize>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3SumcheckDriverPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub batch: String,
-    pub policy: String,
-    pub round_schedule: Vec<usize>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3SumcheckInstanceResultPlan {
-    pub symbol: String,
-    pub source: String,
-    pub claim: String,
-    pub relation: String,
-    pub index: usize,
-    pub point_arity: usize,
-    pub num_rounds: usize,
-    pub round_offset: usize,
-    pub point_order: String,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3SumcheckEvalPlan {
-    pub symbol: String,
-    pub source: String,
-    pub name: String,
-    pub index: usize,
-    pub oracle: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3PointSlicePlan {
-    pub symbol: String,
-    pub source: String,
-    pub offset: usize,
-    pub length: usize,
-    pub input: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3PointConcatPlan {
-    pub symbol: String,
-    pub layout: String,
-    pub arity: usize,
-    pub inputs: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3OpeningClaimPlan {
-    pub symbol: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-    pub point_source: String,
-    pub eval_source: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3OpeningClaimEqualityPlan {
-    pub symbol: String,
-    pub mode: String,
-    pub lhs: String,
-    pub rhs: String,
+fn stage3_scalar_expr(
+    expr: Stage3RelationOutputFieldExprPlan,
+) -> verifier_value_rows::CpuScalarExprPlan {
+    verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands)
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage3OpeningBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-}
+verifier_plan::impl_verifier_plan_source_traits!(program = Stage3CpuProgram,);
 
 pub fn stage3_cpu_program(module: &BoltModule<'_, Cpu>) -> Result<Stage3CpuProgram, EmitError> {
     verify_cpu_schema(module)?;
@@ -225,12 +97,15 @@ impl Stage3CpuProgram {
         let mut opening_inputs = Vec::new();
         let mut field_constants = Vec::new();
         let mut field_exprs = Vec::new();
+        let mut scalar_exprs = Vec::new();
         let mut kernels = Vec::new();
         let mut claims = Vec::new();
         let mut batches = Vec::new();
         let mut drivers = Vec::new();
         let mut instance_results = Vec::new();
         let mut evals = Vec::new();
+        let mut relation_output_values = Vec::new();
+        let mut relation_output_asts = Vec::new();
         let mut point_slices = Vec::new();
         let mut point_concats = Vec::new();
         let mut opening_claims = Vec::new();
@@ -258,266 +133,177 @@ impl Stage3CpuProgram {
                     });
                 }
                 "cpu.transcript_squeeze" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage3ProgramStepPlan {
-                        kind: "transcript_squeeze".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    transcript_squeezes.push(Stage3TranscriptSqueezePlan {
-                        symbol,
-                        label: string_attr(op, "label")?,
-                        kind: string_attr(op, "kind")?,
-                        count: int_attr(op, "count")?,
-                    });
+                    let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "transcript_squeeze",
+                        squeeze.symbol.clone(),
+                    ));
+                    transcript_squeezes.push(squeeze);
                 }
                 "cpu.opening_input" => {
-                    opening_inputs.push(Stage3OpeningInputPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source_stage: symbol_attr(op, "source_stage")?,
-                        source_claim: symbol_attr(op, "source_claim")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                    });
+                    opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?);
                 }
                 "cpu.field_const" => {
-                    field_constants.push(Stage3FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: int_attr(op, "value")?,
-                    });
+                    field_constants
+                        .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?);
                 }
                 "cpu.field_zero" => {
-                    field_constants.push(Stage3FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 0,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?);
                 }
                 "cpu.field_one" => {
-                    field_constants.push(Stage3FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 1,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?);
                 }
                 "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => {
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage3FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: operation_name(op).replace("cpu.field_", "field."),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?);
                 }
                 "cpu.field_pow" => {
-                    let exponent = int_attr(op, "exponent")?;
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage3FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: format!("field.pow:{exponent}"),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?);
                 }
                 "cpu.poly_lagrange_basis_eval" => {
-                    let domain_start = signed_int_attr(op, "domain_start")?;
-                    let domain_size = int_attr(op, "domain_size")?;
-                    let index = int_attr(op, "index")?;
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage3FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: format!(
-                            "poly.lagrange_basis_eval:{domain_start}:{domain_size}:{index}"
-                        ),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs
+                        .push(verifier_value_rows::CpuFieldExprPlan::from_lagrange_basis_eval(op)?);
                 }
                 "cpu.sumcheck_claim" => {
-                    claims.push(Stage3SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim(
+                        op,
+                    )?);
                 }
                 "cpu.sumcheck_verify_claim" => {
-                    claims.push(Stage3SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims
+                        .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?);
                 }
                 "cpu.sumcheck_batch" => {
-                    batches.push(Stage3SumcheckBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                    });
+                    batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_driver" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage3ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage3SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_verify" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage3ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage3SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_instance_result" => {
-                    instance_results.push(Stage3SumcheckInstanceResultPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        claim: symbol_attr(op, "claim")?,
-                        relation: symbol_attr(op, "relation")?,
-                        index: int_attr(op, "index")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        round_offset: int_attr(op, "round_offset")?,
-                        point_order: string_attr(op, "point_order")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    instance_results
+                        .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_eval" => {
-                    evals.push(Stage3SumcheckEvalPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        name: symbol_attr(op, "name")?,
-                        index: int_attr(op, "index")?,
-                        oracle: symbol_attr(op, "oracle")?,
+                    evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?);
+                }
+                "cpu.structured_polynomial_eval" => {
+                    relation_output_values.push(
+                        verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?,
+                    );
+                }
+                "cpu.sumcheck_output_claim" => {
+                    relation_output_asts.push(Stage3RelationOutputAst {
+                        relation: symbol_attr(op, "relation")?,
+                        expected_output: operand_symbol(op, 0)?,
+                        polynomial_evals: symbol_array_attr(op, "polynomial_evals")?,
+                        polynomial_eval_operands: operand_symbols(op, 1)?,
                     });
                 }
                 "cpu.point_slice" => {
-                    point_slices.push(Stage3PointSlicePlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        offset: int_attr(op, "offset")?,
-                        length: int_attr(op, "length")?,
-                        input: operand_symbol(op, 0)?,
-                    });
+                    point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?);
                 }
                 "cpu.point_concat" => {
-                    point_concats.push(Stage3PointConcatPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        layout: string_attr(op, "layout")?,
-                        arity: int_attr(op, "arity")?,
-                        inputs: operand_symbols(op, 0)?,
-                    });
+                    point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim" => {
-                    opening_claims.push(Stage3OpeningClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                        point_source: operand_symbol(op, 0)?,
-                        eval_source: operand_symbol(op, 1)?,
-                    });
+                    opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim_equal" => {
-                    opening_equalities.push(Stage3OpeningClaimEqualityPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        mode: string_attr(op, "mode")?,
-                        lhs: operand_symbol(op, 0)?,
-                        rhs: operand_symbol(op, 1)?,
-                    });
+                    opening_equalities
+                        .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?);
                 }
                 "cpu.opening_batch" => {
-                    opening_batches.push(Stage3OpeningBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                    });
+                    opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?);
                 }
                 _ => {}
             }
         }
 
-        Ok(Self {
+        let role = module
+            .role()
+            .ok_or_else(|| EmitError::new("missing cpu party role"))?;
+        let is_verifier = role == Role::Verifier;
+        if is_verifier {
+            scalar_exprs.extend(
+                relation_output_values
+                    .iter()
+                    .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan)
+                    .map(stage3_scalar_expr),
+            );
+        }
+        if role == Role::Prover {
+            verifier_relation_outputs::prune_output_only_field_exprs(
+                &mut field_exprs,
+                claims.iter().map(|claim| claim.claim_value.as_str()),
+                relation_output_asts
+                    .iter()
+                    .map(|claim| claim.expected_output.as_str()),
+            );
+        }
+        let relation_outputs = if role == Role::Verifier {
+            verifier_relation_outputs::resolve_relation_outputs(
+                "stage3",
+                &relation_output_values,
+                &[],
+                &[],
+                &[],
+                &field_exprs,
+                relation_output_asts,
+            )?
+        } else {
+            Vec::new()
+        };
+
+        let mut program = Self {
             params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?,
-            role: module
-                .role()
-                .ok_or_else(|| EmitError::new("missing cpu party role"))?,
+            role,
+            verifier_plan: None,
             steps,
             transcript_squeezes,
             opening_inputs,
             field_constants,
             field_exprs,
+            scalar_exprs,
             kernels,
             claims,
             batches,
             drivers,
             instance_results,
             evals,
+            relation_output_values,
+            relation_outputs,
             point_slices,
             point_concats,
             opening_claims,
             opening_equalities,
             opening_batches,
-        })
+        };
+        if is_verifier {
+            program.verifier_plan = Some(program.plan_verifier()?);
+        }
+        Ok(program)
+    }
+
+    fn plan_verifier(&self) -> Result<VerifierStagePlan, EmitError> {
+        verifier_plan::plan_verifier_stage_from_cpu_sources(self)
+    }
+
+    fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> {
+        self.verifier_plan
+            .as_ref()
+            .ok_or_else(|| EmitError::new("missing stage3 verifier plan"))
     }
 
     fn verify_supported_target(&self) -> Result<(), EmitError> {
@@ -526,13 +312,19 @@ impl Stage3CpuProgram {
         require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?;
         self.verify_transcript_squeezes()?;
         self.verify_field_flow()?;
-        self.verify_claim_batches()?;
         match self.role {
             Role::Prover => {
+                self.verify_claim_batches()?;
                 self.verify_kernel_definitions()?;
                 self.verify_prover_driver_bindings()?;
             }
-            Role::Verifier => self.verify_verifier_driver_bindings()?,
+            Role::Verifier => {
+                self.verifier_plan()?.verify_sumcheck_flow("stage3")?;
+                self.verify_verifier_driver_bindings()?;
+            }
+        }
+        if self.role == Role::Verifier {
+            self.verify_relation_outputs()?;
         }
         self.verify_opening_flow()
     }
@@ -562,23 +354,41 @@ impl Stage3CpuProgram {
         for constant in &self.field_constants {
             require_supported_symbol("field constant field", &constant.field, "bn254_fr")?;
         }
-        let field_values = self.field_value_symbols();
-        for expr in &self.field_exprs {
-            verify_count(
-                "field expr operands",
-                &expr.symbol,
-                expr.operand_names.len(),
-                expr.operands.len(),
-            )?;
-            for operand in &expr.operands {
-                if !field_values.contains(operand) {
-                    return Err(EmitError::new(format!(
-                        "field expr @{} references missing field value @{operand}",
-                        expr.symbol
-                    )));
-                }
-            }
-        }
+        let verifier_plan = if self.role == Role::Verifier {
+            Some(self.verifier_plan()?)
+        } else {
+            None
+        };
+        let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values());
+        let field_values = verifier_scalar_values.as_ref().map_or_else(
+            || self.cpu_field_value_sources(),
+            |values| values.source_set(),
+        );
+        let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values());
+        let verifier_point_values = verifier_plan.map(|plan| plan.point_values());
+        let point_values = verifier_point_values
+            .as_ref()
+            .map(|values| values.source_set());
+        super::plan_tokens::verify_field_expr_flow(
+            super::plan_tokens::FieldExprFlowVerification {
+                cpu_exprs: &self.field_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+            },
+        )?;
+        super::plan_tokens::verify_scalar_expr_flow(
+            super::plan_tokens::ScalarExprFlowVerification {
+                stage: "stage3",
+                cpu_exprs: &self.scalar_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+                field_vector_values: field_vector_values.as_ref(),
+                point_values: point_values.as_ref(),
+                verifier_point_values: verifier_point_values.as_ref(),
+            },
+        )?;
         for claim in &self.claims {
             if !field_values.contains(&claim.claim_value) {
                 return Err(EmitError::new(format!(
@@ -590,19 +400,35 @@ impl Stage3CpuProgram {
         Ok(())
     }
 
-    fn field_value_symbols(&self) -> BTreeSet<String> {
-        let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
-        values.extend(symbols(
+    fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet {
+        let mut values = verifier_values::VerifierScalarSourceSet::default();
+        values.extend(
+            self.opening_inputs.iter().map(|input| &input.symbol),
+            verifier_values::VerifierScalarSourceKind::OpeningInput,
+        );
+        values.extend(
             self.field_constants.iter().map(|constant| &constant.symbol),
-        ));
-        values.extend(symbols(
+            verifier_values::VerifierScalarSourceKind::FieldConstant,
+        );
+        values.extend(
             self.transcript_squeezes
                 .iter()
                 .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar"))
                 .map(|squeeze| &squeeze.symbol),
-        ));
-        values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol)));
-        values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol)));
+            verifier_values::VerifierScalarSourceKind::TranscriptScalar,
+        );
+        values.extend(
+            self.field_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::FieldExpr,
+        );
+        values.extend(
+            self.scalar_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::ScalarExpr,
+        );
+        values.extend(
+            self.evals.iter().map(|eval| &eval.symbol),
+            verifier_values::VerifierScalarSourceKind::SumcheckEval,
+        );
         values
     }
 
@@ -737,11 +563,6 @@ impl Stage3CpuProgram {
                 "verifier stage3 program must not contain kernels",
             ));
         }
-        let batches: BTreeMap<_, _> = self
-            .batches
-            .iter()
-            .map(|batch| (batch.symbol.as_str(), batch))
-            .collect();
         for claim in &self.claims {
             if claim.kernel.is_some() || claim.relation.is_none() {
                 return Err(EmitError::new(format!(
@@ -757,29 +578,18 @@ impl Stage3CpuProgram {
                     driver.symbol
                 )));
             }
-            let batch = batches.get(driver.batch.as_str()).ok_or_else(|| {
-                EmitError::new(format!(
-                    "sumcheck driver @{} references missing batch @{}",
-                    driver.symbol, driver.batch
-                ))
-            })?;
-            verify_count(
-                "sumcheck driver round_schedule",
-                &driver.symbol,
-                driver.num_rounds,
-                driver.round_schedule.iter().sum(),
-            )?;
-            if driver.round_schedule != batch.round_schedule {
-                return Err(EmitError::new(format!(
-                    "sumcheck driver @{} round_schedule differs from batch @{}",
-                    driver.symbol, batch.symbol
-                )));
-            }
         }
         Ok(())
     }
 
+    fn verify_relation_outputs(&self) -> Result<(), EmitError> {
+        self.verifier_plan()?.verify_relation_outputs("stage3")
+    }
+
     fn verify_opening_flow(&self) -> Result<(), EmitError> {
+        if self.role == Role::Verifier {
+            return self.verifier_plan()?.verify_opening_flow("stage3");
+        }
         let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol));
         point_sources.extend(symbols(
             self.instance_results
@@ -811,7 +621,7 @@ impl Stage3CpuProgram {
                 }
             }
         }
-        let eval_sources = self.field_value_symbols();
+        let eval_sources = self.cpu_field_value_sources();
         let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
         opening_sources.extend(symbols(
             self.opening_claims.iter().map(|claim| &claim.symbol),
@@ -954,9 +764,8 @@ impl Stage3CpuProgram {
     }
 
     fn emit_verifier_imports() -> &'static str {
-        "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\
+        "use bolt_verifier_runtime::find_plan;\n\
          use jolt_field::{Field, Fr};\n\
-         use jolt_poly::{EqPlusOnePolynomial, EqPolynomial};\n\
          use jolt_sumcheck::SumcheckError;\n\
          use jolt_transcript::{Blake2bTranscript, Transcript};"
     }
@@ -964,26 +773,35 @@ impl Stage3CpuProgram {
     fn emit_verifier_types() -> &'static str {
         r"pub type DefaultStage3Transcript = Blake2bTranscript<Fr>;
 
-pub type Stage3NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage3SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage3ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage3ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage3Proof<F> = super::common::StageProof<F>;
-pub type Stage3OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-pub type Stage3VerifierProgramPlan = super::common::StageVerifierProgramPlan;
-
-pub use super::common::{
-    FieldConstantPlan as Stage3FieldConstantPlan, FieldExprPlan as Stage3FieldExprPlan,
+pub type Stage3NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage3SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage3ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage3ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage3Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage3OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage3VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlan<Stage3RelationKind>;
+pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage3RelationKind>;
+pub type Stage3SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage3RelationKind>;
+pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage3RelationKind>;
+pub type Stage3RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage3RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage3ClaimKind, FieldConstantPlan as Stage3FieldConstantPlan,
+    FieldExprKind as Stage3FieldExprKind,
+    FieldExprPlan as Stage3FieldExprPlan,
+    ScalarExprKind as Stage3ScalarExprKind,
+    ScalarExprPlan as Stage3ScalarExprPlan,
     OpeningBatchPlan as Stage3OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan,
-    PointConcatPlan as Stage3PointConcatPlan, PointSlicePlan as Stage3PointSlicePlan,
-    ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params,
+    PointExprKind as Stage3PointExprKind, PointExprPlan as Stage3PointExprPlan,
+    OpeningEqualityMode as Stage3OpeningEqualityMode,
+    ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan,
+    StageParams as Stage3Params,
     SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage3SumcheckInstanceResultPlan,
+    TranscriptSqueezeKind as Stage3TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage3TranscriptSqueezePlan,
-    SumcheckClaimPlan as Stage3SumcheckClaimPlan,
-    SumcheckDriverPlan as Stage3SumcheckDriverPlan,
 };
 
 #[derive(Debug)]
@@ -995,22 +813,21 @@ pub enum VerifyStage3Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage3RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error);
 "
     }
 
     fn emit_prover_constants(&self) -> Result<String, EmitError> {
-        let mut source = self.emit_shared_constants();
+        let mut source = self.emit_shared_constants()?;
         source.push_str(&self.emit_kernel_constants());
         source.push_str(&self.emit_prover_sumcheck_claim_constants()?);
         source.push_str(&self.emit_sumcheck_batch_constants());
         source.push_str(&self.emit_prover_sumcheck_driver_constants()?);
-        source.push_str(&self.emit_tail_constants());
+        source.push_str(&self.emit_tail_constants()?);
         source.push_str(
             "pub const STAGE3_PROGRAM: Stage3CpuProgramPlan = Stage3CpuProgramPlan {\n\
              \x20   params: STAGE3_PARAMS,\n\
@@ -1036,11 +853,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
     }
 
     fn emit_verifier_constants(&self) -> Result<String, EmitError> {
-        let mut source = self.emit_shared_constants();
+        let mut source = self.emit_shared_constants()?;
         source.push_str(&self.emit_verifier_sumcheck_claim_constants()?);
         source.push_str(&self.emit_sumcheck_batch_constants());
         source.push_str(&self.emit_verifier_sumcheck_driver_constants()?);
-        source.push_str(&self.emit_tail_constants());
+        source.push_str(&self.emit_tail_constants()?);
+        source.push_str(&self.emit_verifier_relation_output_constants()?);
         source.push_str(
             "pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan {\n\
              \x20   params: STAGE3_PARAMS,\n\
@@ -1049,13 +867,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
              \x20   opening_inputs: STAGE3_OPENING_INPUTS,\n\
              \x20   field_constants: STAGE3_FIELD_CONSTANTS,\n\
              \x20   field_exprs: STAGE3_FIELD_EXPRS,\n\
+             \x20   scalar_exprs: STAGE3_SCALAR_EXPRS,\n\
              \x20   claims: STAGE3_SUMCHECK_CLAIMS,\n\
              \x20   batches: STAGE3_SUMCHECK_BATCHES,\n\
              \x20   drivers: STAGE3_SUMCHECK_DRIVERS,\n\
              \x20   instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS,\n\
              \x20   evals: STAGE3_SUMCHECK_EVALS,\n\
-             \x20   point_slices: STAGE3_POINT_SLICES,\n\
-             \x20   point_concats: STAGE3_POINT_CONCATS,\n\
+             \x20   relation_outputs: STAGE3_RELATION_OUTPUTS,\n\
+             \x20   point_exprs: STAGE3_POINT_EXPRS,\n\
              \x20   opening_claims: STAGE3_OPENING_CLAIMS,\n\
              \x20   opening_equalities: STAGE3_OPENING_EQUALITIES,\n\
              \x20   opening_batches: STAGE3_OPENING_BATCHES,\n\
@@ -1064,71 +883,102 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
         Ok(source)
     }
 
-    fn emit_shared_constants(&self) -> String {
+    fn emit_shared_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE3_PARAMS: Stage3Params = Stage3Params {{\n\
-             \x20   field: {},\n\
-             \x20   pcs: {},\n\
-             \x20   transcript: {},\n\
-             }};\n",
+                "pub const STAGE3_PARAMS: Stage3Params = Stage3Params {{ field: {}, pcs: {}, transcript: {} }};\n",
                 rust_str(&self.params.field),
                 rust_str(&self.params.pcs),
                 rust_str(&self.params.transcript)
             ),
         );
-        source.push_str(&self.emit_program_step_constants());
-        source.push_str(&self.emit_transcript_squeeze_constants());
-        source.push_str(&self.emit_opening_input_constants());
+        source.push_str(&self.emit_program_step_constants()?);
+        source.push_str(&self.emit_transcript_squeeze_constants()?);
+        source.push_str(&self.emit_opening_input_constants()?);
         source.push_str(&self.emit_field_constant_constants());
-        source.push_str(&self.emit_field_expr_constants());
-        source
+        source.push_str(&self.emit_field_expr_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_scalar_expr_constants()?);
+        }
+        Ok(source)
     }
 
-    fn emit_program_step_constants(&self) -> String {
+    fn emit_program_step_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_program_step_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.steps,
+            ));
+        }
         let steps = self
             .steps
             .iter()
             .map(|step| {
-                format!(
+                Ok(format!(
                     "    Stage3ProgramStepPlan {{ kind: {}, symbol: {} }},",
-                    rust_str(&step.kind),
+                    super::plan_tokens::role_program_step_kind_expr(
+                        "Stage3", &self.role, &step.kind
+                    )?,
                     rust_str(&step.symbol),
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[\n{steps}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[\n{steps}\n];\n\n"
+        ))
     }
 
-    fn emit_transcript_squeeze_constants(&self) -> String {
+    fn emit_transcript_squeeze_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_transcript_squeeze_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.transcript_squeezes,
+            ));
+        }
         let squeezes = self
             .transcript_squeezes
             .iter()
             .map(|squeeze| {
-                format!(
+                Ok(format!(
                     "    Stage3TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},",
                     rust_str(&squeeze.symbol),
                     rust_str(&squeeze.label),
-                    rust_str(&squeeze.kind),
+                    super::plan_tokens::role_transcript_squeeze_kind_expr(
+                        "Stage3",
+                        &self.role,
+                        &squeeze.kind
+                    )?,
                     squeeze.count,
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE3_TRANSCRIPT_SQUEEZES: &[Stage3TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_opening_input_constants(&self) -> String {
+    fn emit_opening_input_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_input_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.opening_inputs,
+            ));
+        }
         let inputs = self
             .opening_inputs
             .iter()
             .map(|input| {
-                format!(
+                Ok(format!(
                     "    Stage3OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},",
                     rust_str(&input.symbol),
                     rust_str(&input.source_stage),
@@ -1136,12 +986,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
                     rust_str(&input.oracle),
                     rust_str(&input.domain),
                     input.point_arity,
-                    rust_str(&input.claim_kind)
-                )
+                    super::plan_tokens::role_claim_kind_expr("Stage3", &self.role, &input.claim_kind)?
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE3_OPENING_INPUTS: &[Stage3OpeningInputPlan] = &[\n{inputs}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE3_OPENING_INPUTS: &[Stage3OpeningInputPlan] = &[\n{inputs}\n];\n\n"
+        ))
     }
 
     fn emit_field_constant_constants(&self) -> String {
@@ -1163,25 +1015,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
         )
     }
 
-    fn emit_field_expr_constants(&self) -> String {
+    fn emit_field_expr_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let exprs = self
-                .field_exprs
-                .iter()
-                .map(|expr| {
-                    format!(
-                        "    Stage3FieldExprPlan {{ symbol: {}, kind: {}, formula: {}, operands: {} }},",
-                        rust_str(&expr.symbol),
-                        rust_str(&expr.kind),
-                        rust_str(&expr.formula),
-                        rust_str(&expr.operands.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[\n{exprs}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_field_expr_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.field_exprs,
+            ));
         }
 
         let mut source = String::new();
@@ -1223,7 +1064,16 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
                 "pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[\n{exprs}\n];\n"
             ),
         );
-        source
+        Ok(source)
+    }
+
+    fn emit_scalar_expr_constants(&self) -> Result<String, EmitError> {
+        let plan = self.verifier_plan()?;
+        Ok(verifier_plan::emit_scalar_expr_constants(
+            "Stage3",
+            "STAGE3",
+            &plan.scalar_exprs,
+        ))
     }
 
     fn emit_kernel_constants(&self) -> String {
@@ -1254,23 +1104,28 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
     }
 
     fn emit_sumcheck_claim_constants(&self, prover: bool) -> Result<String, EmitError> {
+        if !prover {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_claim_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.claims,
+            ));
+        }
         let mut source = String::new();
-        if prover {
-            for (index, claim) in self.claims.iter().enumerate() {
-                source.push_str(&emit_str_array(
-                    &format!("STAGE3_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS"),
-                    &claim.input_openings,
-                ));
-            }
+        for (index, claim) in self.claims.iter().enumerate() {
+            source.push_str(&emit_str_array(
+                &format!("STAGE3_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS"),
+                &claim.input_openings,
+            ));
         }
         let mut claims = Vec::new();
         for (index, claim) in self.claims.iter().enumerate() {
-            if prover {
-                let kernel = claim
-                    .kernel
-                    .as_deref()
-                    .ok_or_else(|| missing_role_binding("prover claim kernel", &claim.symbol))?;
-                claims.push(format!(
+            let kernel = claim
+                .kernel
+                .as_deref()
+                .ok_or_else(|| missing_role_binding("prover claim kernel", &claim.symbol))?;
+            claims.push(format!(
                         "    Stage3SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: Some({}), relation: None, claim_value: {}, input_openings: STAGE3_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},",
                         rust_str(&claim.symbol),
                         rust_str(&claim.stage),
@@ -1281,23 +1136,6 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
                         rust_str(kernel),
                         rust_str(&claim.claim_value)
                     ));
-            } else {
-                let relation = claim.relation.as_deref().ok_or_else(|| {
-                    missing_role_binding("verifier claim relation", &claim.symbol)
-                })?;
-                claims.push(format!(
-                        "    Stage3SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {}, input_openings: {} }},",
-                        rust_str(&claim.symbol),
-                        rust_str(&claim.stage),
-                        rust_str(&claim.domain),
-                        claim.num_rounds,
-                        claim.degree,
-                        rust_str(&claim.claim),
-                        rust_str(relation),
-                        rust_str(&claim.claim_value),
-                        rust_str(&claim.input_openings.join("|"))
-                    ));
-            }
         }
         let claims = claims.join("\n");
         push_format(
@@ -1324,14 +1162,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
                 .enumerate()
                 .map(|(index, batch)| {
                     format!(
-                        "    Stage3SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE3_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
+                        "    Stage3SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE3_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
                         rust_str(&batch.symbol),
                         rust_str(&batch.stage),
                         rust_str(&batch.proof_slot),
                         rust_str(&batch.policy),
                         batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|")),
+                        super::plan_tokens::rust_str_slice_expr(&batch.claim_operands),
                         rust_str(&batch.claim_label),
                         rust_str(&batch.round_label)
                     )
@@ -1398,6 +1235,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
     }
 
     fn emit_sumcheck_driver_constants(&self, prover: bool) -> Result<String, EmitError> {
+        if !prover {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_driver_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.drivers,
+            ));
+        }
         let mut source = String::new();
         for (index, driver) in self.drivers.iter().enumerate() {
             source.push_str(&emit_usize_array(
@@ -1407,12 +1252,11 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
         }
         let mut drivers = Vec::new();
         for (index, driver) in self.drivers.iter().enumerate() {
-            if prover {
-                let kernel = driver
-                    .kernel
-                    .as_deref()
-                    .ok_or_else(|| missing_role_binding("prover driver kernel", &driver.symbol))?;
-                drivers.push(format!(
+            let kernel = driver
+                .kernel
+                .as_deref()
+                .ok_or_else(|| missing_role_binding("prover driver kernel", &driver.symbol))?;
+            drivers.push(format!(
                         "    Stage3SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: Some({}), relation: None, batch: {}, policy: {}, round_schedule: STAGE3_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},",
                         rust_str(&driver.symbol),
                         rust_str(&driver.stage),
@@ -1425,24 +1269,6 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
                         driver.num_rounds,
                         driver.degree
                     ));
-            } else {
-                let relation = driver.relation.as_deref().ok_or_else(|| {
-                    missing_role_binding("verifier driver relation", &driver.symbol)
-                })?;
-                drivers.push(format!(
-                        "    Stage3SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: None, relation: Some({}), batch: {}, policy: {}, round_schedule: STAGE3_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},",
-                        rust_str(&driver.symbol),
-                        rust_str(&driver.stage),
-                        rust_str(&driver.proof_slot),
-                        rust_str(relation),
-                        rust_str(&driver.batch),
-                        rust_str(&driver.policy),
-                        rust_str(&driver.claim_label),
-                        rust_str(&driver.round_label),
-                        driver.num_rounds,
-                        driver.degree
-                    ));
-            }
         }
         let drivers = drivers.join("\n");
         push_format(
@@ -1454,42 +1280,56 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
         Ok(source)
     }
 
-    fn emit_tail_constants(&self) -> String {
+    fn emit_tail_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
-        source.push_str(&self.emit_sumcheck_instance_result_constants());
+        source.push_str(&self.emit_sumcheck_instance_result_constants()?);
         source.push_str(&self.emit_sumcheck_eval_constants());
-        source.push_str(&self.emit_point_slice_constants());
-        source.push_str(&self.emit_point_concat_constants());
-        source.push_str(&self.emit_opening_claim_constants());
-        source.push_str(&self.emit_opening_claim_equality_constants());
+        source.push_str(&self.emit_point_constants()?);
+        source.push_str(&self.emit_opening_claim_constants()?);
+        source.push_str(&self.emit_opening_claim_equality_constants()?);
         source.push_str(&self.emit_opening_batch_constants());
-        source
+        Ok(source)
     }
 
-    fn emit_sumcheck_instance_result_constants(&self) -> String {
+    fn emit_sumcheck_instance_result_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_instance_result_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.instance_results,
+            ));
+        }
         let instances = self
             .instance_results
             .iter()
             .map(|instance| {
-                format!(
+                Ok(format!(
                     "    Stage3SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},",
                     rust_str(&instance.symbol),
                     rust_str(&instance.source),
                     rust_str(&instance.claim),
-                    rust_str(&instance.relation),
+                    super::plan_tokens::role_relation_kind_expr(
+                        "Stage3",
+                        &self.role,
+                        &instance.relation
+                    )?,
                     instance.index,
                     instance.point_arity,
                     instance.num_rounds,
                     instance.round_offset,
-                    rust_str(&instance.point_order),
+                    super::plan_tokens::role_sumcheck_point_order_expr(
+                        &self.role,
+                        &instance.point_order
+                    )?,
                     instance.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE3_SUMCHECK_INSTANCE_RESULTS: &[Stage3SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n"
-        )
+        ))
     }
 
     fn emit_sumcheck_eval_constants(&self) -> String {
@@ -1511,7 +1351,25 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
         format!("pub const STAGE3_SUMCHECK_EVALS: &[Stage3SumcheckEvalPlan] = &[\n{evals}\n];\n\n")
     }
 
-    fn emit_point_slice_constants(&self) -> String {
+    fn emit_verifier_relation_output_constants(&self) -> Result<String, EmitError> {
+        super::relation_outputs::emit_verifier_relation_output_constants(
+            "Stage3",
+            &self.role,
+            &self.relation_outputs,
+        )
+    }
+
+    fn emit_point_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_point_expr_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.point_exprs,
+            ));
+        }
+
+        let mut source = String::new();
         let slices = self
             .point_slices
             .iter()
@@ -1527,31 +1385,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!("pub const STAGE3_POINT_SLICES: &[Stage3PointSlicePlan] = &[\n{slices}\n];\n\n")
-    }
-
-    fn emit_point_concat_constants(&self) -> String {
-        if self.role == Role::Verifier {
-            let concats = self
-                .point_concats
-                .iter()
-                .map(|concat| {
-                    format!(
-                        "    Stage3PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},",
-                        rust_str(&concat.symbol),
-                        rust_str(&concat.layout),
-                        concat.arity,
-                        rust_str(&concat.inputs.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE3_POINT_CONCATS: &[Stage3PointConcatPlan] = &[\n{concats}\n];\n"
-            );
-        }
-
-        let mut source = String::new();
+        push_format(
+            &mut source,
+            format_args!(
+                "pub const STAGE3_POINT_SLICES: &[Stage3PointSlicePlan] = &[\n{slices}\n];\n\n"
+            ),
+        );
         for (index, concat) in self.point_concats.iter().enumerate() {
             source.push_str(&emit_str_array(
                 &format!("STAGE3_POINT_CONCAT_{index}_INPUTS"),
@@ -1578,48 +1417,70 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
                 "pub const STAGE3_POINT_CONCATS: &[Stage3PointConcatPlan] = &[\n{concats}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_opening_claim_constants(&self) -> String {
+    fn emit_opening_claim_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.opening_claims,
+            ));
+        }
         let claims = self
             .opening_claims
             .iter()
             .map(|claim| {
-                format!(
+                Ok(format!(
                     "    Stage3OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.oracle),
                     rust_str(&claim.domain),
                     claim.point_arity,
-                    rust_str(&claim.claim_kind),
+                    super::plan_tokens::role_claim_kind_expr("Stage3", &self.role, &claim.claim_kind)?,
                     rust_str(&claim.point_source),
                     rust_str(&claim.eval_source)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE3_OPENING_CLAIMS: &[Stage3OpeningClaimPlan] = &[\n{claims}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE3_OPENING_CLAIMS: &[Stage3OpeningClaimPlan] = &[\n{claims}\n];\n\n"
+        ))
     }
 
-    fn emit_opening_claim_equality_constants(&self) -> String {
+    fn emit_opening_claim_equality_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_equality_constants(
+                "Stage3",
+                "STAGE3",
+                &plan.opening_equalities,
+            ));
+        }
         let equalities = self
             .opening_equalities
             .iter()
             .map(|equality| {
-                format!(
+                Ok(format!(
                     "    Stage3OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},",
                     rust_str(&equality.symbol),
-                    rust_str(&equality.mode),
+                    super::plan_tokens::role_opening_equality_mode_expr(
+                        "Stage3",
+                        &self.role,
+                        &equality.mode
+                    )?,
                     rust_str(&equality.lhs),
                     rust_str(&equality.rhs)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n"
-        )
+        ))
     }
 
     fn emit_opening_batch_constants(&self) -> String {
@@ -1635,8 +1496,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
                         rust_str(&batch.proof_slot),
                         rust_str(&batch.policy),
                         batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|"))
+                        super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims),
+                        super::plan_tokens::rust_str_slice_expr(&batch.claim_operands)
                     )
                 })
                 .collect::<Vec<_>>()
@@ -1735,26 +1596,26 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
     let mut artifacts = Stage3ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage3ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage3Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage3_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "sumcheck_driver" => {
+            Stage3ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage3Error::MissingProof {
                         driver: step.symbol,
                     })?;
                 verify_stage3_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?;
             }
-            _ => {
+            Stage3ProgramStepKind::TranscriptAbsorbBytes => {
                 return Err(VerifyStage3Error::InvalidProof {
                     driver: step.symbol,
                     reason: "unsupported stage3 program step",
@@ -1775,7 +1636,7 @@ pub fn stage3_verifier_program() -> &'static Stage3VerifierProgramPlan {
 fn verify_stage3_squeeze<T>(
     program: &'static Stage3VerifierProgramPlan,
     squeeze: &'static Stage3TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage3ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage3Error>
@@ -1791,7 +1652,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage3Error::from)?;
     artifacts.challenge_vectors.push(Stage3ChallengeVector {
         symbol: squeeze.symbol,
@@ -1804,7 +1665,7 @@ fn verify_stage3_driver<T>(
     program: &'static Stage3VerifierProgramPlan,
     driver: &'static Stage3SumcheckDriverPlan,
     proof: &Stage3Proof<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage3ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage3Error>
@@ -1817,16 +1678,17 @@ where
         .ok_or(VerifyStage3Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage3Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage3.batched" => {
+        Stage3RelationKind::Stage3Batched => {
             verify_batched_stage3(program, driver, proof, store, transcript)?
         }
-        _ => {
-            return Err(VerifyStage3Error::UnsupportedRelation {
-                relation,
-            });
-        }
+        relation => return Err(VerifyStage3Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -1836,25 +1698,48 @@ fn verify_batched_stage3<T>(
     program: &'static Stage3VerifierProgramPlan,
     driver: &'static Stage3SumcheckDriverPlan,
     proof: &Stage3SumcheckOutput<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage3SumcheckOutput<Fr>, VerifyStage3Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage3Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs)
+            bolt_verifier_runtime::evaluate_relation_output_batch(
+                driver,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                &[],
+                store,
+                evals,
+                point,
+                batching_coeffs,
+                |_, _, _| Ok::<_, VerifyStage3Error>(bolt_verifier_runtime::RelationOutputInputs::empty()),
+            )
         },
         |store, verified| observe_stage3_sumcheck_output(program, store, verified),
         |driver, error| VerifyStage3Error::Sumcheck { driver, error },
@@ -1863,7 +1748,7 @@ where
 
 fn observe_stage3_sumcheck_output<F: Field>(
     program: &'static Stage3VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage3SumcheckOutput<F>,
 ) -> Result<(), VerifyStage3Error> {
     store.observe_sumcheck_output(
@@ -1872,12 +1757,12 @@ fn observe_stage3_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                _ => {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
                     return Err(VerifyStage3Error::InvalidProof {
                         driver: output.driver,
-                        reason: "unsupported point order",
+                        reason: "unsupported relation-local point order",
                     });
                 }
             }
@@ -1891,8 +1776,7 @@ fn observe_stage3_sumcheck_output<F: Field>(
         |symbol| VerifyStage3Error::MissingValue { symbol },
     )?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage3Error::InvalidInputLength {
             input,
             expected,
@@ -1900,7 +1784,7 @@ fn observe_stage3_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage3Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -1909,129 +1793,6 @@ fn observe_stage3_sumcheck_output<F: Field>(
     )
 }
 
-fn expected_batched_output_claim(
-    program: &'static Stage3VerifierProgramPlan,
-    driver: &'static Stage3SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage3NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage3Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage3Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage3Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let value = match instance.relation {
-            "jolt.stage3.spartan_shift" => {
-                expected_spartan_shift(store, evals, local_point)?
-            }
-            "jolt.stage3.instruction_input" => {
-                expected_instruction_input(store, evals, local_point)?
-            }
-            "jolt.stage3.registers_claim_reduction" => {
-                expected_registers(store, evals, local_point)?
-            }
-            _ => {
-                return Err(VerifyStage3Error::UnsupportedRelation {
-                    relation: instance.relation,
-                });
-            }
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_spartan_shift(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage3NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage3Error> {
-    let opening_point = reverse_slice(local_point);
-    let eq_outer =
-        EqPlusOnePolynomial::<Fr>::new(super::common::store_point(store, "stage3.input.stage1.NextPC")?.to_vec())
-            .evaluate(&opening_point);
-    let eq_product = EqPlusOnePolynomial::<Fr>::new(
-        super::common::store_point(store, "stage3.input.stage2.product_virtual.NextIsNoop")?
-            .to_vec(),
-    )
-    .evaluate(&opening_point);
-    let weighted_outer = eval_by_name(evals, "stage3.spartan_shift.eval.UnexpandedPC")?
-        + super::common::store_scalar(store, "stage3.spartan_shift.gamma")?
-            * eval_by_name(evals, "stage3.spartan_shift.eval.PC")?
-        + super::common::store_scalar(store, "stage3.spartan_shift.gamma2")?
-            * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagVirtualInstruction")?
-        + super::common::store_scalar(store, "stage3.spartan_shift.gamma3")?
-            * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagIsFirstInSequence")?;
-    Ok(eq_outer * weighted_outer
-        + super::common::store_scalar(store, "stage3.spartan_shift.gamma4")?
-            * eq_product
-            * (Fr::from_u64(1)
-                - eval_by_name(evals, "stage3.spartan_shift.eval.InstructionFlagIsNoop")?))
-}
-
-fn expected_instruction_input(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage3NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage3Error> {
-    let opening_point = reverse_slice(local_point);
-    let eq_eval = EqPolynomial::<Fr>::mle(
-        &opening_point,
-        super::common::store_point(store, "stage3.input.stage2.product_virtual.LeftInstructionInput")?,
-    );
-    let left = eval_by_name(
-        evals,
-        "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value",
-    )? * eval_by_name(evals, "stage3.instruction_input.eval.Rs1Value")?
-        + eval_by_name(
-            evals,
-            "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC",
-        )? * eval_by_name(evals, "stage3.instruction_input.eval.UnexpandedPC")?;
-    let right = eval_by_name(
-        evals,
-        "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value",
-    )? * eval_by_name(evals, "stage3.instruction_input.eval.Rs2Value")?
-        + eval_by_name(
-            evals,
-            "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm",
-        )? * eval_by_name(evals, "stage3.instruction_input.eval.Imm")?;
-    Ok(eq_eval * (right + super::common::store_scalar(store, "stage3.instruction_input.gamma")? * left))
-}
-
-fn expected_registers(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage3NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage3Error> {
-    let opening_point = reverse_slice(local_point);
-    let eq_eval = EqPolynomial::<Fr>::mle(
-        &opening_point,
-        super::common::store_point(store, "stage3.input.stage1.RdWriteValue")?,
-    );
-    Ok(eq_eval
-        * (eval_by_name(evals, "stage3.registers_claim_reduction.eval.RdWriteValue")?
-            + super::common::store_scalar(store, "stage3.registers.gamma")?
-                * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs1Value")?
-            + super::common::store_scalar(store, "stage3.registers.gamma2")?
-                * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs2Value")?))
-}
-
 "#
     }
 }
@@ -2064,10 +1825,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String {
 fn emit_usize_array(name: &str, values: &[usize]) -> String {
     let entries = values
         .iter()
-        .map(|value| format!("    {value},"))
+        .map(usize::to_string)
         .collect::<Vec<_>>()
-        .join("\n");
-    format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n")
+        .join(", ");
+    format!("pub const {name}: &[usize] = &[{entries}];\n\n")
 }
 
 fn intern_str_array(
@@ -2109,137 +1870,3 @@ fn missing_role_binding(kind: &str, symbol: &str) -> EmitError {
 fn symbols<'a>(values: impl Iterator<Item = &'a String>) -> BTreeSet<String> {
     values.cloned().collect()
 }
-
-fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(string_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "string"))
-}
-
-fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(symbol_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "symbol"))
-}
-
-fn symbol_array_attr(
-    operation: OperationRef<'_, '_>,
-    attr: &str,
-) -> Result<Vec<String>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "symbol array"))?;
-    parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array"))
-}
-
-fn parse_symbol_array(attribute: &str) -> Option<Vec<String>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
-    }
-    inner
-        .split(',')
-        .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned))
-        .collect()
-}
-
-fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<usize, EmitError> {
-    operation
-        .attribute(attr)
-        .map(parse_integer_attr)
-        .ok()
-        .flatten()
-        .ok_or_else(|| attr_error(operation, attr, "integer"))
-}
-
-fn signed_int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<isize, EmitError> {
-    operation
-        .attribute(attr)
-        .map(parse_signed_integer_attr)
-        .ok()
-        .flatten()
-        .ok_or_else(|| attr_error(operation, attr, "signed integer"))
-}
-
-fn parse_integer_attr(attribute: Attribute<'_>) -> Option<usize> {
-    attribute
-        .to_string()
-        .split_whitespace()
-        .next()
-        .and_then(|value| value.parse().ok())
-}
-
-fn parse_signed_integer_attr(attribute: Attribute<'_>) -> Option<isize> {
-    attribute
-        .to_string()
-        .split_whitespace()
-        .next()
-        .and_then(|value| value.parse().ok())
-}
-
-fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<Vec<usize>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "integer array"))?;
-    parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array"))
-}
-
-fn parse_int_array(attribute: &str) -> Option<Vec<usize>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
-    }
-    inner
-        .split(',')
-        .map(|item| item.trim().parse().ok())
-        .collect()
-}
-
-fn operand_symbols(
-    operation: OperationRef<'_, '_>,
-    start_index: usize,
-) -> Result<Vec<String>, EmitError> {
-    (start_index..operation.operand_count())
-        .map(|index| operand_symbol(operation, index))
-        .collect()
-}
-
-fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result<String, EmitError> {
-    let operand = operation.operand(index).map_err(|_| {
-        EmitError::new(format!(
-            "{} requires operand {index}",
-            operation_name(operation)
-        ))
-    })?;
-    let owner = OperationResult::try_from(operand).map_err(|_| {
-        EmitError::new(format!(
-            "{} operand {index} must be an op result",
-            operation_name(operation)
-        ))
-    })?;
-    string_attr(owner.owner(), "sym_name")
-}
-
-fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError {
-    EmitError::new(format!(
-        "{} attr `{attr}` is not a {expected}",
-        operation_name(operation)
-    ))
-}
-
-fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String {
-    operation
-        .name()
-        .as_string_ref()
-        .as_str()
-        .unwrap_or("<invalid-operation-name>")
-        .to_owned()
-}
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs
index b0b5c0ca63..568a102803 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs
@@ -6,34 +6,53 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use melior::ir::block::BlockLike;
-use melior::ir::operation::{OperationLike, OperationResult};
-use melior::ir::{Attribute, OperationRef};
+use melior::ir::operation::OperationLike;
 
 use crate::emit::rust::{push_format, EmitError, RustSourceFile};
-use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role};
+use crate::ir::{BoltModule, Cpu, Role};
+use crate::protocols::jolt::cpu_attrs::{
+    operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr,
+};
+use crate::protocols::jolt::verifier_opening_rows;
+use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan};
+use crate::protocols::jolt::verifier_point_rows;
+use crate::protocols::jolt::verifier_program_rows;
+use crate::protocols::jolt::verifier_relation_outputs::{
+    self, RelationOutputAst as Stage4RelationOutputAst,
+    RelationOutputFieldExprPlan as Stage4RelationOutputFieldExprPlan,
+    RelationOutputPlan as Stage4RelationOutputPlan,
+    StructuredPolynomialEvalPlan as Stage4StructuredPolynomialEvalPlan,
+};
+use crate::protocols::jolt::verifier_sumcheck_rows;
+use crate::protocols::jolt::verifier_value_rows;
+use crate::protocols::jolt::verifier_values;
 use crate::schema::verify_cpu_schema;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Stage4CpuProgram {
     pub role: Role,
+    pub(crate) verifier_plan: Option<VerifierStagePlan>,
     pub params: Stage4Params,
-    pub steps: Vec<Stage4ProgramStepPlan>,
-    pub transcript_squeezes: Vec<Stage4TranscriptSqueezePlan>,
-    pub transcript_absorb_bytes: Vec<Stage4TranscriptAbsorbBytesPlan>,
-    pub opening_inputs: Vec<Stage4OpeningInputPlan>,
-    pub field_constants: Vec<Stage4FieldConstantPlan>,
-    pub field_exprs: Vec<Stage4FieldExprPlan>,
+    pub steps: Vec<verifier_program_rows::CpuProgramStepPlan>,
+    pub transcript_squeezes: Vec<verifier_program_rows::CpuTranscriptSqueezePlan>,
+    pub transcript_absorb_bytes: Vec<verifier_program_rows::CpuTranscriptAbsorbBytesPlan>,
+    pub opening_inputs: Vec<verifier_program_rows::CpuOpeningInputPlan>,
+    pub field_constants: Vec<verifier_value_rows::CpuFieldConstantPlan>,
+    pub field_exprs: Vec<verifier_value_rows::CpuFieldExprPlan>,
+    pub scalar_exprs: Vec<verifier_value_rows::CpuScalarExprPlan>,
     pub kernels: Vec<Stage4KernelPlan>,
-    pub claims: Vec<Stage4SumcheckClaimPlan>,
-    pub batches: Vec<Stage4SumcheckBatchPlan>,
-    pub drivers: Vec<Stage4SumcheckDriverPlan>,
-    pub instance_results: Vec<Stage4SumcheckInstanceResultPlan>,
-    pub evals: Vec<Stage4SumcheckEvalPlan>,
-    pub point_slices: Vec<Stage4PointSlicePlan>,
-    pub point_concats: Vec<Stage4PointConcatPlan>,
-    pub opening_claims: Vec<Stage4OpeningClaimPlan>,
-    pub opening_equalities: Vec<Stage4OpeningClaimEqualityPlan>,
-    pub opening_batches: Vec<Stage4OpeningBatchPlan>,
+    pub claims: Vec<verifier_sumcheck_rows::CpuSumcheckClaimPlan>,
+    pub batches: Vec<verifier_sumcheck_rows::CpuSumcheckBatchPlan>,
+    pub drivers: Vec<verifier_sumcheck_rows::CpuSumcheckDriverPlan>,
+    pub instance_results: Vec<verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan>,
+    pub evals: Vec<verifier_sumcheck_rows::CpuSumcheckEvalPlan>,
+    pub relation_output_values: Vec<Stage4StructuredPolynomialEvalPlan>,
+    pub relation_outputs: Vec<Stage4RelationOutputPlan>,
+    pub point_slices: Vec<verifier_point_rows::CpuPointSlicePlan>,
+    pub point_concats: Vec<verifier_point_rows::CpuPointConcatPlan>,
+    pub opening_claims: Vec<verifier_opening_rows::CpuOpeningClaimPlan>,
+    pub opening_equalities: Vec<verifier_opening_rows::CpuOpeningClaimEqualityPlan>,
+    pub opening_batches: Vec<verifier_opening_rows::CpuOpeningBatchPlan>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -52,167 +71,16 @@ pub struct Stage4KernelPlan {
     pub abi: String,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4TranscriptSqueezePlan {
-    pub symbol: String,
-    pub label: String,
-    pub kind: String,
-    pub count: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4TranscriptAbsorbBytesPlan {
-    pub symbol: String,
-    pub label: String,
-    pub payload: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4ProgramStepPlan {
-    pub kind: String,
-    pub symbol: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4OpeningInputPlan {
-    pub symbol: String,
-    pub source_stage: String,
-    pub source_claim: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4FieldConstantPlan {
-    pub symbol: String,
-    pub field: String,
-    pub value: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4FieldExprPlan {
-    pub symbol: String,
-    pub kind: String,
-    pub formula: String,
-    pub operand_names: Vec<String>,
-    pub operands: Vec<String>,
+fn stage4_scalar_expr(
+    expr: Stage4RelationOutputFieldExprPlan,
+) -> verifier_value_rows::CpuScalarExprPlan {
+    verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands)
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4SumcheckClaimPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub domain: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-    pub claim: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub claim_value: String,
-    pub input_openings: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4SumcheckBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub round_schedule: Vec<usize>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4SumcheckDriverPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub batch: String,
-    pub policy: String,
-    pub round_schedule: Vec<usize>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4SumcheckInstanceResultPlan {
-    pub symbol: String,
-    pub source: String,
-    pub claim: String,
-    pub relation: String,
-    pub index: usize,
-    pub point_arity: usize,
-    pub num_rounds: usize,
-    pub round_offset: usize,
-    pub point_order: String,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4SumcheckEvalPlan {
-    pub symbol: String,
-    pub source: String,
-    pub name: String,
-    pub index: usize,
-    pub oracle: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4PointSlicePlan {
-    pub symbol: String,
-    pub source: String,
-    pub offset: usize,
-    pub length: usize,
-    pub input: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4PointConcatPlan {
-    pub symbol: String,
-    pub layout: String,
-    pub arity: usize,
-    pub inputs: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4OpeningClaimPlan {
-    pub symbol: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-    pub point_source: String,
-    pub eval_source: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4OpeningClaimEqualityPlan {
-    pub symbol: String,
-    pub mode: String,
-    pub lhs: String,
-    pub rhs: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage4OpeningBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-}
+verifier_plan::impl_verifier_plan_source_traits!(
+    program = Stage4CpuProgram,
+    absorb = transcript_absorb_bytes,
+);
 
 pub fn stage4_cpu_program(module: &BoltModule<'_, Cpu>) -> Result<Stage4CpuProgram, EmitError> {
     verify_cpu_schema(module)?;
@@ -226,7 +94,7 @@ pub fn emit_stage4_rust(module: &BoltModule<'_, Cpu>) -> Result<RustSourceFile,
 
     Ok(RustSourceFile {
         filename: program.filename().to_owned(),
-        source: program.emit_source(),
+        source: program.emit_source()?,
     })
 }
 
@@ -239,12 +107,15 @@ impl Stage4CpuProgram {
         let mut opening_inputs = Vec::new();
         let mut field_constants = Vec::new();
         let mut field_exprs = Vec::new();
+        let mut scalar_exprs = Vec::new();
         let mut kernels = Vec::new();
         let mut claims = Vec::new();
         let mut batches = Vec::new();
         let mut drivers = Vec::new();
         let mut instance_results = Vec::new();
         let mut evals = Vec::new();
+        let mut relation_output_values = Vec::new();
+        let mut relation_output_asts = Vec::new();
         let mut point_slices = Vec::new();
         let mut point_concats = Vec::new();
         let mut opening_claims = Vec::new();
@@ -272,264 +143,182 @@ impl Stage4CpuProgram {
                     });
                 }
                 "cpu.transcript_squeeze" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage4ProgramStepPlan {
-                        kind: "transcript_squeeze".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    transcript_squeezes.push(Stage4TranscriptSqueezePlan {
-                        symbol,
-                        label: string_attr(op, "label")?,
-                        kind: string_attr(op, "kind")?,
-                        count: int_attr(op, "count")?,
-                    });
+                    let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "transcript_squeeze",
+                        squeeze.symbol.clone(),
+                    ));
+                    transcript_squeezes.push(squeeze);
                 }
                 "cpu.transcript_absorb_bytes" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage4ProgramStepPlan {
-                        kind: "transcript_absorb_bytes".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    transcript_absorb_bytes.push(Stage4TranscriptAbsorbBytesPlan {
-                        symbol,
-                        label: string_attr(op, "label")?,
-                        payload: string_attr(op, "payload")?,
-                    });
+                    let absorb = verifier_program_rows::CpuTranscriptAbsorbBytesPlan::from_cpu(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "transcript_absorb_bytes",
+                        absorb.symbol.clone(),
+                    ));
+                    transcript_absorb_bytes.push(absorb);
                 }
                 "cpu.opening_input" => {
-                    opening_inputs.push(Stage4OpeningInputPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source_stage: symbol_attr(op, "source_stage")?,
-                        source_claim: symbol_attr(op, "source_claim")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                    });
+                    opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?);
                 }
                 "cpu.field_const" => {
-                    field_constants.push(Stage4FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: int_attr(op, "value")?,
-                    });
+                    field_constants
+                        .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?);
                 }
                 "cpu.field_zero" => {
-                    field_constants.push(Stage4FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 0,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?);
                 }
                 "cpu.field_one" => {
-                    field_constants.push(Stage4FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 1,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?);
                 }
                 "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => {
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage4FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: operation_name(op).replace("cpu.field_", "field."),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?);
                 }
                 "cpu.field_pow" => {
-                    let exponent = int_attr(op, "exponent")?;
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage4FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: format!("field.pow:{exponent}"),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?);
                 }
                 "cpu.sumcheck_claim" => {
-                    claims.push(Stage4SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim(
+                        op,
+                    )?);
                 }
                 "cpu.sumcheck_verify_claim" => {
-                    claims.push(Stage4SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims
+                        .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?);
                 }
                 "cpu.sumcheck_batch" => {
-                    batches.push(Stage4SumcheckBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                    });
+                    batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_driver" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage4ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage4SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_verify" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage4ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage4SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_instance_result" => {
-                    instance_results.push(Stage4SumcheckInstanceResultPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        claim: symbol_attr(op, "claim")?,
-                        relation: symbol_attr(op, "relation")?,
-                        index: int_attr(op, "index")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        round_offset: int_attr(op, "round_offset")?,
-                        point_order: string_attr(op, "point_order")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    instance_results
+                        .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_eval" => {
-                    evals.push(Stage4SumcheckEvalPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        name: symbol_attr(op, "name")?,
-                        index: int_attr(op, "index")?,
-                        oracle: symbol_attr(op, "oracle")?,
+                    evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?);
+                }
+                "cpu.structured_polynomial_eval" => {
+                    relation_output_values.push(
+                        verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?,
+                    );
+                }
+                "cpu.sumcheck_output_claim" => {
+                    relation_output_asts.push(Stage4RelationOutputAst {
+                        relation: symbol_attr(op, "relation")?,
+                        expected_output: operand_symbol(op, 0)?,
+                        polynomial_evals: symbol_array_attr(op, "polynomial_evals")?,
+                        polynomial_eval_operands: operand_symbols(op, 1)?,
                     });
                 }
                 "cpu.point_slice" => {
-                    point_slices.push(Stage4PointSlicePlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        offset: int_attr(op, "offset")?,
-                        length: int_attr(op, "length")?,
-                        input: operand_symbol(op, 0)?,
-                    });
+                    point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?);
                 }
                 "cpu.point_concat" => {
-                    point_concats.push(Stage4PointConcatPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        layout: string_attr(op, "layout")?,
-                        arity: int_attr(op, "arity")?,
-                        inputs: operand_symbols(op, 0)?,
-                    });
+                    point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim" => {
-                    opening_claims.push(Stage4OpeningClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                        point_source: operand_symbol(op, 0)?,
-                        eval_source: operand_symbol(op, 1)?,
-                    });
+                    opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim_equal" => {
-                    opening_equalities.push(Stage4OpeningClaimEqualityPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        mode: string_attr(op, "mode")?,
-                        lhs: operand_symbol(op, 0)?,
-                        rhs: operand_symbol(op, 1)?,
-                    });
+                    opening_equalities
+                        .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?);
                 }
                 "cpu.opening_batch" => {
-                    opening_batches.push(Stage4OpeningBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                    });
+                    opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?);
                 }
                 _ => {}
             }
         }
 
-        Ok(Self {
+        let role = module
+            .role()
+            .ok_or_else(|| EmitError::new("missing cpu party role"))?;
+        let is_verifier = role == Role::Verifier;
+        if is_verifier {
+            scalar_exprs.extend(
+                relation_output_values
+                    .iter()
+                    .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan)
+                    .map(stage4_scalar_expr),
+            );
+        }
+        if role == Role::Prover {
+            verifier_relation_outputs::prune_output_only_field_exprs(
+                &mut field_exprs,
+                claims.iter().map(|claim| claim.claim_value.as_str()),
+                relation_output_asts
+                    .iter()
+                    .map(|claim| claim.expected_output.as_str()),
+            );
+        }
+        let relation_outputs = if role == Role::Verifier {
+            verifier_relation_outputs::resolve_relation_outputs(
+                "stage4",
+                &relation_output_values,
+                &[],
+                &[],
+                &[],
+                &field_exprs,
+                relation_output_asts,
+            )?
+        } else {
+            Vec::new()
+        };
+
+        let mut program = Self {
             params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?,
-            role: module
-                .role()
-                .ok_or_else(|| EmitError::new("missing cpu party role"))?,
+            role,
+            verifier_plan: None,
             steps,
             transcript_squeezes,
             transcript_absorb_bytes,
             opening_inputs,
             field_constants,
             field_exprs,
+            scalar_exprs,
             kernels,
             claims,
             batches,
             drivers,
             instance_results,
             evals,
+            relation_output_values,
+            relation_outputs,
             point_slices,
             point_concats,
             opening_claims,
             opening_equalities,
             opening_batches,
-        })
+        };
+        if is_verifier {
+            program.verifier_plan = Some(program.plan_verifier()?);
+        }
+        Ok(program)
+    }
+
+    fn plan_verifier(&self) -> Result<VerifierStagePlan, EmitError> {
+        verifier_plan::plan_verifier_stage_from_cpu_sources(self)
+    }
+
+    fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> {
+        self.verifier_plan
+            .as_ref()
+            .ok_or_else(|| EmitError::new("missing stage4 verifier plan"))
     }
 
     fn verify_supported_target(&self) -> Result<(), EmitError> {
@@ -538,13 +327,19 @@ impl Stage4CpuProgram {
         require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?;
         self.verify_transcript_steps()?;
         self.verify_field_flow()?;
-        self.verify_claim_batches()?;
         match self.role {
             Role::Prover => {
+                self.verify_claim_batches()?;
                 self.verify_kernel_definitions()?;
                 self.verify_prover_driver_bindings()?;
             }
-            Role::Verifier => self.verify_verifier_driver_bindings()?,
+            Role::Verifier => {
+                self.verifier_plan()?.verify_sumcheck_flow("stage4")?;
+                self.verify_verifier_driver_bindings()?;
+            }
+        }
+        if self.role == Role::Verifier {
+            self.verify_relation_outputs()?;
         }
         self.verify_opening_flow()
     }
@@ -582,23 +377,41 @@ impl Stage4CpuProgram {
         for constant in &self.field_constants {
             require_supported_symbol("field constant field", &constant.field, "bn254_fr")?;
         }
-        let field_values = self.field_value_symbols();
-        for expr in &self.field_exprs {
-            verify_count(
-                "field expr operands",
-                &expr.symbol,
-                expr.operand_names.len(),
-                expr.operands.len(),
-            )?;
-            for operand in &expr.operands {
-                if !field_values.contains(operand) {
-                    return Err(EmitError::new(format!(
-                        "field expr @{} references missing field value @{operand}",
-                        expr.symbol
-                    )));
-                }
-            }
-        }
+        let verifier_plan = if self.role == Role::Verifier {
+            Some(self.verifier_plan()?)
+        } else {
+            None
+        };
+        let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values());
+        let field_values = verifier_scalar_values.as_ref().map_or_else(
+            || self.cpu_field_value_sources(),
+            |values| values.source_set(),
+        );
+        let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values());
+        let verifier_point_values = verifier_plan.map(|plan| plan.point_values());
+        let point_values = verifier_point_values
+            .as_ref()
+            .map(|values| values.source_set());
+        super::plan_tokens::verify_field_expr_flow(
+            super::plan_tokens::FieldExprFlowVerification {
+                cpu_exprs: &self.field_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+            },
+        )?;
+        super::plan_tokens::verify_scalar_expr_flow(
+            super::plan_tokens::ScalarExprFlowVerification {
+                stage: "stage4",
+                cpu_exprs: &self.scalar_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+                field_vector_values: field_vector_values.as_ref(),
+                point_values: point_values.as_ref(),
+                verifier_point_values: verifier_point_values.as_ref(),
+            },
+        )?;
         for claim in &self.claims {
             if !field_values.contains(&claim.claim_value) {
                 return Err(EmitError::new(format!(
@@ -610,19 +423,35 @@ impl Stage4CpuProgram {
         Ok(())
     }
 
-    fn field_value_symbols(&self) -> BTreeSet<String> {
-        let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
-        values.extend(symbols(
+    fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet {
+        let mut values = verifier_values::VerifierScalarSourceSet::default();
+        values.extend(
+            self.opening_inputs.iter().map(|input| &input.symbol),
+            verifier_values::VerifierScalarSourceKind::OpeningInput,
+        );
+        values.extend(
             self.field_constants.iter().map(|constant| &constant.symbol),
-        ));
-        values.extend(symbols(
+            verifier_values::VerifierScalarSourceKind::FieldConstant,
+        );
+        values.extend(
             self.transcript_squeezes
                 .iter()
                 .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar"))
                 .map(|squeeze| &squeeze.symbol),
-        ));
-        values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol)));
-        values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol)));
+            verifier_values::VerifierScalarSourceKind::TranscriptScalar,
+        );
+        values.extend(
+            self.field_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::FieldExpr,
+        );
+        values.extend(
+            self.scalar_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::ScalarExpr,
+        );
+        values.extend(
+            self.evals.iter().map(|eval| &eval.symbol),
+            verifier_values::VerifierScalarSourceKind::SumcheckEval,
+        );
         values
     }
 
@@ -756,11 +585,6 @@ impl Stage4CpuProgram {
                 "verifier stage4 program must not contain kernels",
             ));
         }
-        let batches: BTreeMap<_, _> = self
-            .batches
-            .iter()
-            .map(|batch| (batch.symbol.as_str(), batch))
-            .collect();
         for claim in &self.claims {
             if claim.kernel.is_some() || claim.relation.is_none() {
                 return Err(EmitError::new(format!(
@@ -776,29 +600,18 @@ impl Stage4CpuProgram {
                     driver.symbol
                 )));
             }
-            let batch = batches.get(driver.batch.as_str()).ok_or_else(|| {
-                EmitError::new(format!(
-                    "sumcheck driver @{} references missing batch @{}",
-                    driver.symbol, driver.batch
-                ))
-            })?;
-            verify_count(
-                "sumcheck driver round_schedule",
-                &driver.symbol,
-                driver.num_rounds,
-                driver.round_schedule.iter().sum(),
-            )?;
-            if driver.round_schedule != batch.round_schedule {
-                return Err(EmitError::new(format!(
-                    "sumcheck driver @{} round_schedule differs from batch @{}",
-                    driver.symbol, batch.symbol
-                )));
-            }
         }
         Ok(())
     }
 
+    fn verify_relation_outputs(&self) -> Result<(), EmitError> {
+        self.verifier_plan()?.verify_relation_outputs("stage4")
+    }
+
     fn verify_opening_flow(&self) -> Result<(), EmitError> {
+        if self.role == Role::Verifier {
+            return self.verifier_plan()?.verify_opening_flow("stage4");
+        }
         let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol));
         point_sources.extend(symbols(
             self.instance_results
@@ -830,7 +643,7 @@ impl Stage4CpuProgram {
                 }
             }
         }
-        let eval_sources = self.field_value_symbols();
+        let eval_sources = self.cpu_field_value_sources();
         let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
         opening_sources.extend(symbols(
             self.opening_claims.iter().map(|claim| &claim.symbol),
@@ -929,7 +742,7 @@ impl Stage4CpuProgram {
         }
     }
 
-    fn emit_source(&self) -> String {
+    fn emit_source(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         source.push_str("#![allow(dead_code)]\n\n");
         match self.role {
@@ -945,10 +758,10 @@ impl Stage4CpuProgram {
             }
         }
         source.push('\n');
-        source.push_str(&self.emit_constants());
+        source.push_str(&self.emit_constants()?);
         source.push('\n');
         source.push_str(self.emit_entrypoint());
-        source
+        Ok(source)
     }
 
     fn emit_prover_imports() -> &'static str {
@@ -962,9 +775,8 @@ impl Stage4CpuProgram {
     }
 
     fn emit_verifier_imports() -> &'static str {
-        "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, lt_polynomial_eval, reverse_slice};\n\
+        "use bolt_verifier_runtime::find_plan;\n\
          use jolt_field::{Field, Fr};\n\
-         use jolt_poly::EqPolynomial;\n\
          use jolt_sumcheck::SumcheckError;\n\
          use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};"
     }
@@ -1175,26 +987,36 @@ pub struct Stage4CpuProgramPlan {
     }
 
     fn emit_verifier_type_aliases() -> &'static str {
-        r#"pub type Stage4NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage4SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage4ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage4ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage4Proof<F> = super::common::StageProof<F>;
-pub type Stage4OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-
-pub use super::common::{
-    FieldConstantPlan as Stage4FieldConstantPlan, FieldExprPlan as Stage4FieldExprPlan,
+        r#"pub type Stage4NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage4SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage4ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage4ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage4Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage4OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan<Stage4RelationKind>;
+pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage4RelationKind>;
+pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage4RelationKind>;
+pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage4RelationKind>;
+pub type Stage4RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage4RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage4ClaimKind, FieldConstantPlan as Stage4FieldConstantPlan,
+    FieldExprKind as Stage4FieldExprKind,
+    FieldExprPlan as Stage4FieldExprPlan,
+    ScalarExprKind as Stage4ScalarExprKind,
+    ScalarExprPlan as Stage4ScalarExprPlan,
     KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan,
-    PointConcatPlan as Stage4PointConcatPlan, PointSlicePlan as Stage4PointSlicePlan,
+    OpeningEqualityMode as Stage4OpeningEqualityMode, PointExprKind as Stage4PointExprKind,
+    PointExprPlan as Stage4PointExprPlan,
+    ProgramStepKind as Stage4ProgramStepKind,
     ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params,
-    StageProgramPlanNoPointZeros as Stage4CpuProgramPlan,
     SumcheckBatchPlan as Stage4SumcheckBatchPlan,
-    SumcheckClaimPlan as Stage4SumcheckClaimPlan, SumcheckDriverPlan as Stage4SumcheckDriverPlan,
     SumcheckEvalPlan as Stage4SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage4SumcheckInstanceResultPlan,
     TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan,
+    TranscriptSqueezeKind as Stage4TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage4TranscriptSqueezePlan,
 };
 "#
@@ -1216,24 +1038,46 @@ pub enum VerifyStage4Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage4RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error);
 "#,
         );
         source
     }
 
-    fn emit_constants(&self) -> String {
-        let mut source = self.emit_shared_constants();
+    fn emit_constants(&self) -> Result<String, EmitError> {
+        let mut source = self.emit_shared_constants()?;
         source.push_str(&self.emit_kernel_constants());
-        source.push_str(&self.emit_sumcheck_claim_constants());
+        source.push_str(&self.emit_sumcheck_claim_constants()?);
         source.push_str(&self.emit_sumcheck_batch_constants());
-        source.push_str(&self.emit_sumcheck_driver_constants());
-        source.push_str(&self.emit_tail_constants());
+        source.push_str(&self.emit_sumcheck_driver_constants()?);
+        source.push_str(&self.emit_tail_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_verifier_relation_output_constants()?);
+        }
+        let relation_outputs_field = if self.role == Role::Verifier {
+            "    relation_outputs: STAGE4_RELATION_OUTPUTS,\n"
+        } else {
+            ""
+        };
+        let indexed_eval_families_field = if self.role == Role::Verifier {
+            "    indexed_eval_families: &[],\n"
+        } else {
+            ""
+        };
+        let scalar_exprs_field = if self.role == Role::Verifier {
+            "    scalar_exprs: STAGE4_SCALAR_EXPRS,\n"
+        } else {
+            ""
+        };
+        let point_exprs_field = if self.role == Role::Verifier {
+            "    point_exprs: STAGE4_POINT_EXPRS,\n"
+        } else {
+            "    point_slices: STAGE4_POINT_SLICES,\n    point_concats: STAGE4_POINT_CONCATS,\n"
+        };
         push_format(
             &mut source,
             format_args!(
@@ -1246,14 +1090,16 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                  \x20   opening_inputs: STAGE4_OPENING_INPUTS,\n\
                  \x20   field_constants: STAGE4_FIELD_CONSTANTS,\n\
                  \x20   field_exprs: STAGE4_FIELD_EXPRS,\n\
+                 {scalar_exprs_field}\
                  \x20   kernels: STAGE4_KERNELS,\n\
                  \x20   claims: STAGE4_SUMCHECK_CLAIMS,\n\
                  \x20   batches: STAGE4_SUMCHECK_BATCHES,\n\
                  \x20   drivers: STAGE4_SUMCHECK_DRIVERS,\n\
                  \x20   instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS,\n\
                  \x20   evals: STAGE4_SUMCHECK_EVALS,\n\
-                 \x20   point_slices: STAGE4_POINT_SLICES,\n\
-                 \x20   point_concats: STAGE4_POINT_CONCATS,\n\
+                 {indexed_eval_families_field}\
+                 {relation_outputs_field}\
+                 {point_exprs_field}\
                  \x20   opening_claims: STAGE4_OPENING_CLAIMS,\n\
                  \x20   opening_equalities: STAGE4_OPENING_EQUALITIES,\n\
                  \x20   opening_batches: STAGE4_OPENING_BATCHES,\n\
@@ -1262,70 +1108,97 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                 rust_str(self.role_label())
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_shared_constants(&self) -> String {
+    fn emit_shared_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE4_PARAMS: Stage4Params = Stage4Params {{\n\
-                 \x20   field: {},\n\
-                 \x20   pcs: {},\n\
-                 \x20   transcript: {},\n\
-                 }};\n",
+                "pub const STAGE4_PARAMS: Stage4Params = Stage4Params {{ field: {}, pcs: {}, transcript: {} }};\n",
                 rust_str(&self.params.field),
                 rust_str(&self.params.pcs),
                 rust_str(&self.params.transcript)
             ),
         );
-        source.push_str(&self.emit_program_step_constants());
-        source.push_str(&self.emit_transcript_squeeze_constants());
-        source.push_str(&self.emit_transcript_absorb_bytes_constants());
-        source.push_str(&self.emit_opening_input_constants());
+        source.push_str(&self.emit_program_step_constants()?);
+        source.push_str(&self.emit_transcript_squeeze_constants()?);
+        source.push_str(&self.emit_transcript_absorb_bytes_constants()?);
+        source.push_str(&self.emit_opening_input_constants()?);
         source.push_str(&self.emit_field_constant_constants());
-        source.push_str(&self.emit_field_expr_constants());
-        source
+        source.push_str(&self.emit_field_expr_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_scalar_expr_constants()?);
+        }
+        Ok(source)
     }
 
-    fn emit_program_step_constants(&self) -> String {
+    fn emit_program_step_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_program_step_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.steps,
+            ));
+        }
         let steps = self
             .steps
             .iter()
             .map(|step| {
-                format!(
+                Ok(format!(
                     "    Stage4ProgramStepPlan {{ kind: {}, symbol: {} }},",
-                    rust_str(&step.kind),
+                    super::plan_tokens::role_program_step_kind_expr(
+                        "Stage4", &self.role, &step.kind
+                    )?,
                     rust_str(&step.symbol),
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE4_PROGRAM_STEPS: &[Stage4ProgramStepPlan] = &[\n{steps}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE4_PROGRAM_STEPS: &[Stage4ProgramStepPlan] = &[\n{steps}\n];\n\n"
+        ))
     }
 
-    fn emit_transcript_squeeze_constants(&self) -> String {
+    fn emit_transcript_squeeze_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_transcript_squeeze_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.transcript_squeezes,
+            ));
+        }
         let squeezes = self
             .transcript_squeezes
             .iter()
             .map(|squeeze| {
-                format!(
+                Ok(format!(
                     "    Stage4TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},",
                     rust_str(&squeeze.symbol),
                     rust_str(&squeeze.label),
-                    rust_str(&squeeze.kind),
+                    super::plan_tokens::role_transcript_squeeze_kind_expr("Stage4", &self.role, &squeeze.kind)?,
                     squeeze.count,
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE4_TRANSCRIPT_SQUEEZES: &[Stage4TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_transcript_absorb_bytes_constants(&self) -> String {
+    fn emit_transcript_absorb_bytes_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_transcript_absorb_bytes_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.transcript_absorb_bytes,
+            ));
+        }
         let absorbs = self
             .transcript_absorb_bytes
             .iter()
@@ -1339,17 +1212,25 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE4_TRANSCRIPT_ABSORB_BYTES: &[Stage4TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_opening_input_constants(&self) -> String {
+    fn emit_opening_input_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_input_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.opening_inputs,
+            ));
+        }
         let inputs = self
             .opening_inputs
             .iter()
             .map(|input| {
-                format!(
+                Ok(format!(
                     "    Stage4OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},",
                     rust_str(&input.symbol),
                     rust_str(&input.source_stage),
@@ -1357,12 +1238,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                     rust_str(&input.oracle),
                     rust_str(&input.domain),
                     input.point_arity,
-                    rust_str(&input.claim_kind)
-                )
+                    super::plan_tokens::role_claim_kind_expr("Stage4", &self.role, &input.claim_kind)?
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE4_OPENING_INPUTS: &[Stage4OpeningInputPlan] = &[\n{inputs}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE4_OPENING_INPUTS: &[Stage4OpeningInputPlan] = &[\n{inputs}\n];\n\n"
+        ))
     }
 
     fn emit_field_constant_constants(&self) -> String {
@@ -1384,25 +1267,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
         )
     }
 
-    fn emit_field_expr_constants(&self) -> String {
+    fn emit_field_expr_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let exprs = self
-                .field_exprs
-                .iter()
-                .map(|expr| {
-                    format!(
-                        "    Stage4FieldExprPlan {{ symbol: {}, kind: {}, formula: {}, operands: {} }},",
-                        rust_str(&expr.symbol),
-                        rust_str(&expr.kind),
-                        rust_str(&expr.formula),
-                        rust_str(&expr.operands.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[\n{exprs}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_field_expr_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.field_exprs,
+            ));
         }
 
         let mut source = String::new();
@@ -1444,7 +1316,16 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                 "pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[\n{exprs}\n];\n"
             ),
         );
-        source
+        Ok(source)
+    }
+
+    fn emit_scalar_expr_constants(&self) -> Result<String, EmitError> {
+        let plan = self.verifier_plan()?;
+        Ok(verifier_plan::emit_scalar_expr_constants(
+            "Stage4",
+            "STAGE4",
+            &plan.scalar_exprs,
+        ))
     }
 
     fn emit_kernel_constants(&self) -> String {
@@ -1466,31 +1347,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
         format!("pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[\n{kernels}\n];\n\n")
     }
 
-    fn emit_sumcheck_claim_constants(&self) -> String {
+    fn emit_sumcheck_claim_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let claims = self
-                .claims
-                .iter()
-                .map(|claim| {
-                    format!(
-                        "    Stage4SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},",
-                        rust_str(&claim.symbol),
-                        rust_str(&claim.stage),
-                        rust_str(&claim.domain),
-                        claim.num_rounds,
-                        claim.degree,
-                        rust_str(&claim.claim),
-                        rust_option_str(claim.kernel.as_deref()),
-                        rust_option_str(claim.relation.as_deref()),
-                        rust_str(&claim.claim_value),
-                        rust_str(&claim.input_openings.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[\n{claims}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_claim_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.claims,
+            ));
         }
 
         let mut source = String::new();
@@ -1505,7 +1369,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
             .iter()
             .enumerate()
             .map(|(index, claim)| {
-                format!(
+                Ok(format!(
                     "    Stage4SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: STAGE4_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.stage),
@@ -1514,11 +1378,15 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                     claim.degree,
                     rust_str(&claim.claim),
                     rust_option_str(claim.kernel.as_deref()),
-                    rust_option_str(claim.relation.as_deref()),
+                    super::plan_tokens::role_optional_relation_kind_expr(
+                        "Stage4",
+                        &self.role,
+                        claim.relation.as_deref()
+                    )?,
                     rust_str(&claim.claim_value)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
         push_format(
             &mut source,
@@ -1526,7 +1394,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                 "pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[\n{claims}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
     fn emit_sumcheck_batch_constants(&self) -> String {
@@ -1544,14 +1412,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                 .enumerate()
                 .map(|(index, batch)| {
                     format!(
-                        "    Stage4SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE4_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
+                        "    Stage4SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE4_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
                         rust_str(&batch.symbol),
                         rust_str(&batch.stage),
                         rust_str(&batch.proof_slot),
                         rust_str(&batch.policy),
                         batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|")),
+                        super::plan_tokens::rust_str_slice_expr(&batch.claim_operands),
                         rust_str(&batch.claim_label),
                         rust_str(&batch.round_label)
                     )
@@ -1609,7 +1476,15 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
         source
     }
 
-    fn emit_sumcheck_driver_constants(&self) -> String {
+    fn emit_sumcheck_driver_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_driver_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.drivers,
+            ));
+        }
         let mut source = String::new();
         for (index, driver) in self.drivers.iter().enumerate() {
             source.push_str(&emit_usize_array(
@@ -1622,22 +1497,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
             .iter()
             .enumerate()
             .map(|(index, driver)| {
-                format!(
+                Ok(format!(
                     "    Stage4SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: {}, relation: {}, batch: {}, policy: {}, round_schedule: STAGE4_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},",
                     rust_str(&driver.symbol),
                     rust_str(&driver.stage),
                     rust_str(&driver.proof_slot),
                     rust_option_str(driver.kernel.as_deref()),
-                    rust_option_str(driver.relation.as_deref()),
+                    super::plan_tokens::role_optional_relation_kind_expr(
+                        "Stage4",
+                        &self.role,
+                        driver.relation.as_deref()
+                    )?,
                     rust_str(&driver.batch),
                     rust_str(&driver.policy),
                     rust_str(&driver.claim_label),
                     rust_str(&driver.round_label),
                     driver.num_rounds,
                     driver.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
         push_format(
             &mut source,
@@ -1645,45 +1524,59 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                 "pub const STAGE4_SUMCHECK_DRIVERS: &[Stage4SumcheckDriverPlan] = &[\n{drivers}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_tail_constants(&self) -> String {
+    fn emit_tail_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
-        source.push_str(&self.emit_sumcheck_instance_result_constants());
+        source.push_str(&self.emit_sumcheck_instance_result_constants()?);
         source.push_str(&self.emit_sumcheck_eval_constants());
-        source.push_str(&self.emit_point_slice_constants());
-        source.push_str(&self.emit_point_concat_constants());
-        source.push_str(&self.emit_opening_claim_constants());
-        source.push_str(&self.emit_opening_claim_equality_constants());
+        source.push_str(&self.emit_point_constants()?);
+        source.push_str(&self.emit_opening_claim_constants()?);
+        source.push_str(&self.emit_opening_claim_equality_constants()?);
         source.push_str(&self.emit_opening_batch_constants());
-        source
+        Ok(source)
     }
 
-    fn emit_sumcheck_instance_result_constants(&self) -> String {
+    fn emit_sumcheck_instance_result_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_instance_result_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.instance_results,
+            ));
+        }
         let instances = self
             .instance_results
             .iter()
             .map(|instance| {
-                format!(
+                Ok(format!(
                     "    Stage4SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},",
                     rust_str(&instance.symbol),
                     rust_str(&instance.source),
                     rust_str(&instance.claim),
-                    rust_str(&instance.relation),
+                    super::plan_tokens::role_relation_kind_expr(
+                        "Stage4",
+                        &self.role,
+                        &instance.relation
+                    )?,
                     instance.index,
                     instance.point_arity,
                     instance.num_rounds,
                     instance.round_offset,
-                    rust_str(&instance.point_order),
+                    super::plan_tokens::role_sumcheck_point_order_expr(
+                        &self.role,
+                        &instance.point_order
+                    )?,
                     instance.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE4_SUMCHECK_INSTANCE_RESULTS: &[Stage4SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n"
-        )
+        ))
     }
 
     fn emit_sumcheck_eval_constants(&self) -> String {
@@ -1705,7 +1598,25 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
         format!("pub const STAGE4_SUMCHECK_EVALS: &[Stage4SumcheckEvalPlan] = &[\n{evals}\n];\n\n")
     }
 
-    fn emit_point_slice_constants(&self) -> String {
+    fn emit_verifier_relation_output_constants(&self) -> Result<String, EmitError> {
+        super::relation_outputs::emit_verifier_relation_output_constants(
+            "Stage4",
+            &self.role,
+            &self.relation_outputs,
+        )
+    }
+
+    fn emit_point_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_point_expr_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.point_exprs,
+            ));
+        }
+
+        let mut source = String::new();
         let slices = self
             .point_slices
             .iter()
@@ -1721,31 +1632,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!("pub const STAGE4_POINT_SLICES: &[Stage4PointSlicePlan] = &[\n{slices}\n];\n\n")
-    }
-
-    fn emit_point_concat_constants(&self) -> String {
-        if self.role == Role::Verifier {
-            let concats = self
-                .point_concats
-                .iter()
-                .map(|concat| {
-                    format!(
-                        "    Stage4PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},",
-                        rust_str(&concat.symbol),
-                        rust_str(&concat.layout),
-                        concat.arity,
-                        rust_str(&concat.inputs.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE4_POINT_CONCATS: &[Stage4PointConcatPlan] = &[\n{concats}\n];\n"
-            );
-        }
-
-        let mut source = String::new();
+        push_format(
+            &mut source,
+            format_args!(
+                "pub const STAGE4_POINT_SLICES: &[Stage4PointSlicePlan] = &[\n{slices}\n];\n\n"
+            ),
+        );
         for (index, concat) in self.point_concats.iter().enumerate() {
             source.push_str(&emit_str_array(
                 &format!("STAGE4_POINT_CONCAT_{index}_INPUTS"),
@@ -1772,48 +1664,66 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                 "pub const STAGE4_POINT_CONCATS: &[Stage4PointConcatPlan] = &[\n{concats}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_opening_claim_constants(&self) -> String {
+    fn emit_opening_claim_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.opening_claims,
+            ));
+        }
         let claims = self
             .opening_claims
             .iter()
             .map(|claim| {
-                format!(
+                Ok(format!(
                     "    Stage4OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.oracle),
                     rust_str(&claim.domain),
                     claim.point_arity,
-                    rust_str(&claim.claim_kind),
+                    super::plan_tokens::role_claim_kind_expr("Stage4", &self.role, &claim.claim_kind)?,
                     rust_str(&claim.point_source),
                     rust_str(&claim.eval_source)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE4_OPENING_CLAIMS: &[Stage4OpeningClaimPlan] = &[\n{claims}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE4_OPENING_CLAIMS: &[Stage4OpeningClaimPlan] = &[\n{claims}\n];\n\n"
+        ))
     }
 
-    fn emit_opening_claim_equality_constants(&self) -> String {
+    fn emit_opening_claim_equality_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_equality_constants(
+                "Stage4",
+                "STAGE4",
+                &plan.opening_equalities,
+            ));
+        }
         let equalities = self
             .opening_equalities
             .iter()
             .map(|equality| {
-                format!(
+                Ok(format!(
                     "    Stage4OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},",
                     rust_str(&equality.symbol),
-                    rust_str(&equality.mode),
+                    super::plan_tokens::role_opening_equality_mode_expr("Stage4", &self.role, &equality.mode)?,
                     rust_str(&equality.lhs),
                     rust_str(&equality.rhs)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n"
-        )
+        ))
     }
 
     fn emit_opening_batch_constants(&self) -> String {
@@ -1829,8 +1739,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
                         rust_str(&batch.proof_slot),
                         rust_str(&batch.policy),
                         batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|"))
+                        super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims),
+                        super::plan_tokens::rust_str_slice_expr(&batch.claim_operands)
                     )
                 })
                 .collect::<Vec<_>>()
@@ -1930,19 +1840,19 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
     let mut artifacts = Stage4ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage4ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage4Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage4_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "transcript_absorb_bytes" => {
+            Stage4ProgramStepKind::TranscriptAbsorbBytes => {
                 let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or(
                     VerifyStage4Error::MissingValue {
                         symbol: step.symbol,
@@ -1950,19 +1860,13 @@ where
                 )?;
                 absorb_stage4_bytes(absorb, transcript);
             }
-            "sumcheck_driver" => {
+            Stage4ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage4Error::MissingProof {
                         driver: step.symbol,
                     })?;
                 verify_stage4_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?;
             }
-            _ => {
-                return Err(VerifyStage4Error::InvalidProof {
-                    driver: step.symbol,
-                    reason: "unsupported stage4 program step",
-                });
-            }
         }
     }
     artifacts
@@ -1978,7 +1882,7 @@ pub fn stage4_verifier_program() -> &'static Stage4VerifierProgramPlan {
 fn verify_stage4_squeeze<T>(
     program: &'static Stage4VerifierProgramPlan,
     squeeze: &'static Stage4TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage4ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage4Error>
@@ -1994,7 +1898,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage4Error::from)?;
     artifacts.challenge_vectors.push(Stage4ChallengeVector {
         symbol: squeeze.symbol,
@@ -2018,7 +1922,7 @@ fn verify_stage4_driver<T>(
     program: &'static Stage4VerifierProgramPlan,
     driver: &'static Stage4SumcheckDriverPlan,
     proof: &Stage4Proof<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage4ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage4Error>
@@ -2031,12 +1935,17 @@ where
         .ok_or(VerifyStage4Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage4Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage4.batched" => {
+        Stage4RelationKind::Stage4Batched => {
             verify_batched_stage4(program, driver, proof, store, transcript)?
         }
-        _ => return Err(VerifyStage4Error::UnsupportedRelation { relation }),
+        relation => return Err(VerifyStage4Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -2046,25 +1955,48 @@ fn verify_batched_stage4<T>(
     program: &'static Stage4VerifierProgramPlan,
     driver: &'static Stage4SumcheckDriverPlan,
     proof: &Stage4SumcheckOutput<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage4SumcheckOutput<Fr>, VerifyStage4Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage4Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs)
+            bolt_verifier_runtime::evaluate_relation_output_batch(
+                driver,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                &[],
+                store,
+                evals,
+                point,
+                batching_coeffs,
+                |_, _, _| Ok::<_, VerifyStage4Error>(bolt_verifier_runtime::RelationOutputInputs::empty()),
+            )
         },
         |store, verified| observe_stage4_sumcheck_output(program, store, verified),
         |driver, error| VerifyStage4Error::Sumcheck { driver, error },
@@ -2073,7 +2005,7 @@ where
 
 fn observe_stage4_sumcheck_output<F: Field>(
     program: &'static Stage4VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage4SumcheckOutput<F>,
 ) -> Result<(), VerifyStage4Error> {
     store.observe_sumcheck_output(
@@ -2082,17 +2014,17 @@ fn observe_stage4_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                "stage4_registers_rw" => {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
+                    if instance.relation != Stage4RelationKind::Stage4RegistersReadWrite {
+                        return Err(VerifyStage4Error::InvalidProof {
+                            driver: output.driver,
+                            reason: "unsupported relation-local point order",
+                        });
+                    }
                     point = normalize_stage4_registers_rw_point(program, output.driver, &point)?;
                 }
-                _ => {
-                    return Err(VerifyStage4Error::InvalidProof {
-                        driver: output.driver,
-                        reason: "unsupported point order",
-                    });
-                }
             }
             Ok(point)
         },
@@ -2104,8 +2036,7 @@ fn observe_stage4_sumcheck_output<F: Field>(
         |symbol| VerifyStage4Error::MissingValue { symbol },
     )?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage4Error::InvalidInputLength {
             input,
             expected,
@@ -2113,7 +2044,7 @@ fn observe_stage4_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage4Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -2122,108 +2053,6 @@ fn observe_stage4_sumcheck_output<F: Field>(
     )
 }
 
-fn expected_batched_output_claim(
-    program: &'static Stage4VerifierProgramPlan,
-    driver: &'static Stage4SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage4NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage4Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage4Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage4Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let relation = claim.relation.unwrap_or("<missing>");
-        let value = match relation {
-            "jolt.stage4.registers_read_write" => {
-                expected_registers_read_write(store, evals, local_point)?
-            }
-            "jolt.stage4.ram_val_check" => {
-                expected_ram_val_check(store, evals, local_point)?
-            }
-            _ => return Err(VerifyStage4Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_registers_read_write(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage4NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage4Error> {
-    let trace_point = super::common::store_point(store, "stage4.input.stage3.registers.RdWriteValue")?;
-    let r_cycle = normalize_stage4_registers_rw_cycle_point(
-        local_point,
-        trace_point.len(),
-        "stage4.registers_read_write.instance",
-    )?;
-    let eq_eval = EqPolynomial::<Fr>::mle(&r_cycle, trace_point);
-    let registers_val = eval_by_name(
-        evals,
-        "stage4.registers_read_write.eval.RegistersVal",
-    )?;
-    let rs1_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs1Ra")?;
-    let rs2_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs2Ra")?;
-    let rd_wa = eval_by_name(evals, "stage4.registers_read_write.eval.RdWa")?;
-    let rd_inc = eval_by_name(evals, "stage4.registers_read_write.eval.RdInc")?;
-    let gamma = super::common::store_scalar(store, "stage4.registers_read_write.gamma")?;
-    Ok(eq_eval
-        * (rd_wa * (registers_val + rd_inc)
-            + gamma * (rs1_ra * registers_val + gamma * rs2_ra * registers_val)))
-}
-
-fn expected_ram_val_check(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage4NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage4Error> {
-    let ram_val_point = super::common::store_point(store, "stage4.input.stage2.RamVal")?;
-    let r_cycle_prime = reverse_slice(local_point);
-    let r_cycle = suffix_point(
-        ram_val_point,
-        r_cycle_prime.len(),
-        "stage4.input.stage2.RamVal",
-    )?;
-    let lt_eval = lt_polynomial_eval(&r_cycle_prime, r_cycle);
-    let gamma = super::common::store_scalar(store, "stage4.ram_val_check.gamma")?;
-    let ram_ra = eval_by_name(evals, "stage4.ram_val_check.eval.RamRa")?;
-    let ram_inc = eval_by_name(evals, "stage4.ram_val_check.eval.RamInc")?;
-    Ok(ram_inc * ram_ra * (lt_eval + gamma))
-}
-
-fn suffix_point<'a>(
-    point: &'a [Fr],
-    length: usize,
-    input: &'static str,
-) -> Result<&'a [Fr], VerifyStage4Error> {
-    point
-        .get(point.len().saturating_sub(length)..)
-        .filter(|suffix| suffix.len() == length)
-        .ok_or(VerifyStage4Error::InvalidInputLength {
-            input,
-            expected: length,
-            actual: point.len(),
-        })
-}
-
 fn normalize_stage4_registers_rw_point<F: Field>(
     program: &'static Stage4VerifierProgramPlan,
     driver: &'static str,
@@ -2256,22 +2085,6 @@ fn normalize_stage4_registers_rw_point<F: Field>(
         .collect())
 }
 
-fn normalize_stage4_registers_rw_cycle_point<F: Field>(
-    point: &[F],
-    cycle_rounds: usize,
-    input: &'static str,
-) -> Result<Vec<F>, VerifyStage4Error> {
-    let cycle = point
-        .get(..cycle_rounds)
-        .filter(|cycle| cycle.len() == cycle_rounds)
-        .ok_or(VerifyStage4Error::InvalidInputLength {
-            input,
-            expected: cycle_rounds,
-            actual: point.len(),
-        })?;
-    Ok(cycle.iter().rev().copied().collect())
-}
-
 "#
             }
         }
@@ -2320,10 +2133,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String {
 fn emit_usize_array(name: &str, values: &[usize]) -> String {
     let entries = values
         .iter()
-        .map(|value| format!("    {value},"))
+        .map(usize::to_string)
         .collect::<Vec<_>>()
-        .join("\n");
-    format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n")
+        .join(", ");
+    format!("pub const {name}: &[usize] = &[{entries}];\n\n")
 }
 
 fn intern_str_array(
@@ -2368,120 +2181,3 @@ fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Res
 fn symbols<'a>(values: impl Iterator<Item = &'a String>) -> BTreeSet<String> {
     values.cloned().collect()
 }
-
-fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(string_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "string"))
-}
-
-fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(symbol_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "symbol"))
-}
-
-fn symbol_array_attr(
-    operation: OperationRef<'_, '_>,
-    attr: &str,
-) -> Result<Vec<String>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "symbol array"))?;
-    parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array"))
-}
-
-fn parse_symbol_array(attribute: &str) -> Option<Vec<String>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
-    }
-    inner
-        .split(',')
-        .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned))
-        .collect()
-}
-
-fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<usize, EmitError> {
-    operation
-        .attribute(attr)
-        .map(parse_integer_attr)
-        .ok()
-        .flatten()
-        .ok_or_else(|| attr_error(operation, attr, "integer"))
-}
-
-fn parse_integer_attr(attribute: Attribute<'_>) -> Option<usize> {
-    attribute
-        .to_string()
-        .split_whitespace()
-        .next()
-        .and_then(|value| value.parse().ok())
-}
-
-fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<Vec<usize>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "integer array"))?;
-    parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array"))
-}
-
-fn parse_int_array(attribute: &str) -> Option<Vec<usize>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
-    }
-    inner
-        .split(',')
-        .map(|item| item.trim().parse().ok())
-        .collect()
-}
-
-fn operand_symbols(
-    operation: OperationRef<'_, '_>,
-    start_index: usize,
-) -> Result<Vec<String>, EmitError> {
-    (start_index..operation.operand_count())
-        .map(|index| operand_symbol(operation, index))
-        .collect()
-}
-
-fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result<String, EmitError> {
-    let operand = operation.operand(index).map_err(|_| {
-        EmitError::new(format!(
-            "{} requires operand {index}",
-            operation_name(operation)
-        ))
-    })?;
-    let owner = OperationResult::try_from(operand).map_err(|_| {
-        EmitError::new(format!(
-            "{} operand {index} must be an op result",
-            operation_name(operation)
-        ))
-    })?;
-    string_attr(owner.owner(), "sym_name")
-}
-
-fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError {
-    EmitError::new(format!(
-        "{} attr `{attr}` is not a {expected}",
-        operation_name(operation)
-    ))
-}
-
-fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String {
-    operation
-        .name()
-        .as_string_ref()
-        .as_str()
-        .unwrap_or("<invalid-operation-name>")
-        .to_owned()
-}
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs
index 08e3ebf5c5..6abc0f321d 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs
@@ -6,34 +6,66 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use melior::ir::block::BlockLike;
-use melior::ir::operation::{OperationLike, OperationResult};
-use melior::ir::{Attribute, OperationRef};
+use melior::ir::operation::OperationLike;
 
 use crate::emit::rust::{push_format, EmitError, RustSourceFile};
-use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role};
+use crate::ir::{BoltModule, Cpu, Role};
+use crate::protocols::jolt::cpu_attrs::{
+    operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr,
+};
+use crate::protocols::jolt::rust_target_plan::ScalarExprKind;
+use crate::protocols::jolt::stage5_instruction_read_raf_plan::{
+    Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan,
+};
+use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan};
+use crate::protocols::jolt::verifier_opening_rows;
+use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan};
+use crate::protocols::jolt::verifier_point_rows;
+use crate::protocols::jolt::verifier_program_rows;
+use crate::protocols::jolt::verifier_relation_outputs::{
+    self, parse_output_eval_family_plan, parse_output_function_family_plan,
+    parse_output_product_family_plan, RelationOutputAst as Stage5RelationOutputAst,
+    RelationOutputEvalFamilyPlan as Stage5RelationOutputEvalFamilyPlan,
+    RelationOutputFieldExprPlan as Stage5RelationOutputFieldExprPlan,
+    RelationOutputFunctionFamilyPlan as Stage5RelationOutputFunctionFamilyPlan,
+    RelationOutputPlan as Stage5RelationOutputPlan,
+    RelationOutputProductFamilyPlan as Stage5RelationOutputProductFamilyPlan,
+    StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan,
+};
+use crate::protocols::jolt::verifier_sumcheck_rows;
+use crate::protocols::jolt::verifier_value_rows;
+use crate::protocols::jolt::verifier_values;
 use crate::schema::verify_cpu_schema;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Stage5CpuProgram {
     pub role: Role,
+    pub(crate) verifier_plan: Option<VerifierStagePlan>,
+    pub(crate) indexed_eval_families: Vec<IndexedEvalFamilyPlan>,
     pub params: Stage5Params,
-    pub steps: Vec<Stage5ProgramStepPlan>,
-    pub transcript_squeezes: Vec<Stage5TranscriptSqueezePlan>,
-    pub transcript_absorb_bytes: Vec<Stage5TranscriptAbsorbBytesPlan>,
-    pub opening_inputs: Vec<Stage5OpeningInputPlan>,
-    pub field_constants: Vec<Stage5FieldConstantPlan>,
-    pub field_exprs: Vec<Stage5FieldExprPlan>,
+    pub steps: Vec<verifier_program_rows::CpuProgramStepPlan>,
+    pub transcript_squeezes: Vec<verifier_program_rows::CpuTranscriptSqueezePlan>,
+    pub transcript_absorb_bytes: Vec<verifier_program_rows::CpuTranscriptAbsorbBytesPlan>,
+    pub opening_inputs: Vec<verifier_program_rows::CpuOpeningInputPlan>,
+    pub field_constants: Vec<verifier_value_rows::CpuFieldConstantPlan>,
+    pub field_exprs: Vec<verifier_value_rows::CpuFieldExprPlan>,
+    pub scalar_exprs: Vec<verifier_value_rows::CpuScalarExprPlan>,
     pub kernels: Vec<Stage5KernelPlan>,
-    pub claims: Vec<Stage5SumcheckClaimPlan>,
-    pub batches: Vec<Stage5SumcheckBatchPlan>,
-    pub drivers: Vec<Stage5SumcheckDriverPlan>,
-    pub instance_results: Vec<Stage5SumcheckInstanceResultPlan>,
-    pub evals: Vec<Stage5SumcheckEvalPlan>,
-    pub point_slices: Vec<Stage5PointSlicePlan>,
-    pub point_concats: Vec<Stage5PointConcatPlan>,
-    pub opening_claims: Vec<Stage5OpeningClaimPlan>,
-    pub opening_equalities: Vec<Stage5OpeningClaimEqualityPlan>,
-    pub opening_batches: Vec<Stage5OpeningBatchPlan>,
+    pub claims: Vec<verifier_sumcheck_rows::CpuSumcheckClaimPlan>,
+    pub batches: Vec<verifier_sumcheck_rows::CpuSumcheckBatchPlan>,
+    pub drivers: Vec<verifier_sumcheck_rows::CpuSumcheckDriverPlan>,
+    pub instance_results: Vec<verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan>,
+    pub evals: Vec<verifier_sumcheck_rows::CpuSumcheckEvalPlan>,
+    pub relation_output_values: Vec<Stage5StructuredPolynomialEvalPlan>,
+    pub relation_output_eval_families: Vec<Stage5RelationOutputEvalFamilyPlan>,
+    pub relation_output_product_families: Vec<Stage5RelationOutputProductFamilyPlan>,
+    pub relation_output_function_families: Vec<Stage5RelationOutputFunctionFamilyPlan>,
+    pub relation_outputs: Vec<Stage5RelationOutputPlan>,
+    pub point_slices: Vec<verifier_point_rows::CpuPointSlicePlan>,
+    pub point_concats: Vec<verifier_point_rows::CpuPointConcatPlan>,
+    pub opening_claims: Vec<verifier_opening_rows::CpuOpeningClaimPlan>,
+    pub opening_equalities: Vec<verifier_opening_rows::CpuOpeningClaimEqualityPlan>,
+    pub opening_batches: Vec<verifier_opening_rows::CpuOpeningBatchPlan>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -52,167 +84,33 @@ pub struct Stage5KernelPlan {
     pub abi: String,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5TranscriptSqueezePlan {
-    pub symbol: String,
-    pub label: String,
-    pub kind: String,
-    pub count: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5TranscriptAbsorbBytesPlan {
-    pub symbol: String,
-    pub label: String,
-    pub payload: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5ProgramStepPlan {
-    pub kind: String,
-    pub symbol: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5OpeningInputPlan {
-    pub symbol: String,
-    pub source_stage: String,
-    pub source_claim: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5FieldConstantPlan {
-    pub symbol: String,
-    pub field: String,
-    pub value: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5FieldExprPlan {
-    pub symbol: String,
-    pub kind: String,
-    pub formula: String,
-    pub operand_names: Vec<String>,
-    pub operands: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5SumcheckClaimPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub domain: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-    pub claim: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub claim_value: String,
-    pub input_openings: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5SumcheckBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub round_schedule: Vec<usize>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5SumcheckDriverPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub batch: String,
-    pub policy: String,
-    pub round_schedule: Vec<usize>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5SumcheckInstanceResultPlan {
-    pub symbol: String,
-    pub source: String,
-    pub claim: String,
-    pub relation: String,
-    pub index: usize,
-    pub point_arity: usize,
-    pub num_rounds: usize,
-    pub round_offset: usize,
-    pub point_order: String,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5SumcheckEvalPlan {
-    pub symbol: String,
-    pub source: String,
-    pub name: String,
-    pub index: usize,
-    pub oracle: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5PointSlicePlan {
-    pub symbol: String,
-    pub source: String,
-    pub offset: usize,
-    pub length: usize,
-    pub input: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5PointConcatPlan {
-    pub symbol: String,
-    pub layout: String,
-    pub arity: usize,
-    pub inputs: Vec<String>,
+fn stage5_field_expr(
+    expr: Stage5InstructionReadRafOutputFieldExprPlan,
+) -> verifier_value_rows::CpuFieldExprPlan {
+    verifier_value_rows::CpuFieldExprPlan::op(expr.symbol, expr.formula, expr.operands)
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5OpeningClaimPlan {
-    pub symbol: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-    pub point_source: String,
-    pub eval_source: String,
+fn stage5_scalar_expr(
+    expr: Stage5InstructionReadRafOutputFieldExprPlan,
+) -> verifier_value_rows::CpuScalarExprPlan {
+    verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands)
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5OpeningClaimEqualityPlan {
-    pub symbol: String,
-    pub mode: String,
-    pub lhs: String,
-    pub rhs: String,
+fn stage5_relation_output_scalar_expr(
+    expr: Stage5RelationOutputFieldExprPlan,
+) -> verifier_value_rows::CpuScalarExprPlan {
+    verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands)
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage5OpeningBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-}
+verifier_plan::impl_verifier_plan_source_traits!(
+    program = Stage5CpuProgram,
+    absorb = transcript_absorb_bytes,
+    indexed_eval_families = indexed_eval_families,
+    relation_output_eval_families = relation_output_eval_families,
+    relation_output_product_families = relation_output_product_families,
+    relation_output_function_families = relation_output_function_families,
+    relation_local_inputs = stage5_instruction_read_raf,
+);
 
 pub fn stage5_cpu_program(module: &BoltModule<'_, Cpu>) -> Result<Stage5CpuProgram, EmitError> {
     verify_cpu_schema(module)?;
@@ -226,11 +124,17 @@ pub fn emit_stage5_rust(module: &BoltModule<'_, Cpu>) -> Result<RustSourceFile,
 
     Ok(RustSourceFile {
         filename: program.filename().to_owned(),
-        source: program.emit_source(),
+        source: program.emit_source()?,
     })
 }
 
 impl Stage5CpuProgram {
+    pub fn indexed_eval_family_rows(&self) -> impl Iterator<Item = (&str, &[String])> {
+        self.indexed_eval_families
+            .iter()
+            .map(|family| (family.symbol.as_str(), family.evals.as_slice()))
+    }
+
     fn from_module(module: &BoltModule<'_, Cpu>) -> Result<Self, EmitError> {
         let mut params = None;
         let mut steps = Vec::new();
@@ -239,12 +143,19 @@ impl Stage5CpuProgram {
         let mut opening_inputs = Vec::new();
         let mut field_constants = Vec::new();
         let mut field_exprs = Vec::new();
+        let mut scalar_exprs = Vec::new();
         let mut kernels = Vec::new();
         let mut claims = Vec::new();
         let mut batches = Vec::new();
         let mut drivers = Vec::new();
         let mut instance_results = Vec::new();
         let mut evals = Vec::new();
+        let mut indexed_eval_families = Vec::new();
+        let mut relation_output_values = Vec::new();
+        let mut relation_output_eval_families = Vec::new();
+        let mut relation_output_product_families = Vec::new();
+        let mut relation_output_function_families = Vec::new();
+        let mut relation_output_asts = Vec::new();
         let mut point_slices = Vec::new();
         let mut point_concats = Vec::new();
         let mut opening_claims = Vec::new();
@@ -272,264 +183,216 @@ impl Stage5CpuProgram {
                     });
                 }
                 "cpu.transcript_squeeze" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage5ProgramStepPlan {
-                        kind: "transcript_squeeze".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    transcript_squeezes.push(Stage5TranscriptSqueezePlan {
-                        symbol,
-                        label: string_attr(op, "label")?,
-                        kind: string_attr(op, "kind")?,
-                        count: int_attr(op, "count")?,
-                    });
+                    let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "transcript_squeeze",
+                        squeeze.symbol.clone(),
+                    ));
+                    transcript_squeezes.push(squeeze);
                 }
                 "cpu.transcript_absorb_bytes" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage5ProgramStepPlan {
-                        kind: "transcript_absorb_bytes".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    transcript_absorb_bytes.push(Stage5TranscriptAbsorbBytesPlan {
-                        symbol,
-                        label: string_attr(op, "label")?,
-                        payload: string_attr(op, "payload")?,
-                    });
+                    let absorb = verifier_program_rows::CpuTranscriptAbsorbBytesPlan::from_cpu(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "transcript_absorb_bytes",
+                        absorb.symbol.clone(),
+                    ));
+                    transcript_absorb_bytes.push(absorb);
                 }
                 "cpu.opening_input" => {
-                    opening_inputs.push(Stage5OpeningInputPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source_stage: symbol_attr(op, "source_stage")?,
-                        source_claim: symbol_attr(op, "source_claim")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                    });
+                    opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?);
                 }
                 "cpu.field_const" => {
-                    field_constants.push(Stage5FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: int_attr(op, "value")?,
-                    });
+                    field_constants
+                        .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?);
                 }
                 "cpu.field_zero" => {
-                    field_constants.push(Stage5FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 0,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?);
                 }
                 "cpu.field_one" => {
-                    field_constants.push(Stage5FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 1,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?);
                 }
                 "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => {
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage5FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: operation_name(op).replace("cpu.field_", "field."),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?);
                 }
                 "cpu.field_pow" => {
-                    let exponent = int_attr(op, "exponent")?;
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage5FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: format!("field.pow:{exponent}"),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?);
                 }
                 "cpu.sumcheck_claim" => {
-                    claims.push(Stage5SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim(
+                        op,
+                    )?);
                 }
                 "cpu.sumcheck_verify_claim" => {
-                    claims.push(Stage5SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims
+                        .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?);
                 }
                 "cpu.sumcheck_batch" => {
-                    batches.push(Stage5SumcheckBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                    });
+                    batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_driver" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage5ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage5SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_verify" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage5ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage5SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_instance_result" => {
-                    instance_results.push(Stage5SumcheckInstanceResultPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        claim: symbol_attr(op, "claim")?,
-                        relation: symbol_attr(op, "relation")?,
-                        index: int_attr(op, "index")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        round_offset: int_attr(op, "round_offset")?,
-                        point_order: string_attr(op, "point_order")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    instance_results
+                        .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_eval" => {
-                    evals.push(Stage5SumcheckEvalPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        name: symbol_attr(op, "name")?,
-                        index: int_attr(op, "index")?,
-                        oracle: symbol_attr(op, "oracle")?,
+                    evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?);
+                }
+                "cpu.sumcheck_eval_family" => {
+                    indexed_eval_families
+                        .push(verifier_eval_families::parse_indexed_eval_family(op)?);
+                }
+                "cpu.structured_polynomial_eval" => {
+                    relation_output_values.push(
+                        verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?,
+                    );
+                }
+                "cpu.sumcheck_output_eval_family" => {
+                    relation_output_eval_families
+                        .push(parse_output_eval_family_plan("stage5", op)?);
+                }
+                "cpu.sumcheck_output_product_family" => {
+                    relation_output_product_families
+                        .push(parse_output_product_family_plan("stage5", op)?);
+                }
+                "cpu.sumcheck_output_function_family" => {
+                    relation_output_function_families
+                        .push(parse_output_function_family_plan("stage5", op)?);
+                }
+                "cpu.sumcheck_output_claim" => {
+                    relation_output_asts.push(Stage5RelationOutputAst {
+                        relation: symbol_attr(op, "relation")?,
+                        expected_output: operand_symbol(op, 0)?,
+                        polynomial_evals: symbol_array_attr(op, "polynomial_evals")?,
+                        polynomial_eval_operands: operand_symbols(op, 1)?,
                     });
                 }
                 "cpu.point_slice" => {
-                    point_slices.push(Stage5PointSlicePlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        offset: int_attr(op, "offset")?,
-                        length: int_attr(op, "length")?,
-                        input: operand_symbol(op, 0)?,
-                    });
+                    point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?);
                 }
                 "cpu.point_concat" => {
-                    point_concats.push(Stage5PointConcatPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        layout: string_attr(op, "layout")?,
-                        arity: int_attr(op, "arity")?,
-                        inputs: operand_symbols(op, 0)?,
-                    });
+                    point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim" => {
-                    opening_claims.push(Stage5OpeningClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                        point_source: operand_symbol(op, 0)?,
-                        eval_source: operand_symbol(op, 1)?,
-                    });
+                    opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim_equal" => {
-                    opening_equalities.push(Stage5OpeningClaimEqualityPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        mode: string_attr(op, "mode")?,
-                        lhs: operand_symbol(op, 0)?,
-                        rhs: operand_symbol(op, 1)?,
-                    });
+                    opening_equalities
+                        .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?);
                 }
                 "cpu.opening_batch" => {
-                    opening_batches.push(Stage5OpeningBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                    });
+                    opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?);
                 }
                 _ => {}
             }
         }
 
-        Ok(Self {
+        let role = module
+            .role()
+            .ok_or_else(|| EmitError::new("missing cpu party role"))?;
+        let is_verifier = role == Role::Verifier;
+        if role == Role::Prover {
+            verifier_relation_outputs::prune_output_only_field_exprs(
+                &mut field_exprs,
+                claims.iter().map(|claim| claim.claim_value.as_str()),
+                relation_output_asts
+                    .iter()
+                    .map(|claim| claim.expected_output.as_str()),
+            );
+        }
+        let mut relation_outputs = if role == Role::Verifier {
+            verifier_relation_outputs::resolve_relation_outputs(
+                "stage5",
+                &relation_output_values,
+                &relation_output_eval_families,
+                &relation_output_product_families,
+                &relation_output_function_families,
+                &field_exprs,
+                relation_output_asts,
+            )?
+        } else {
+            Vec::new()
+        };
+        if role == Role::Verifier {
+            let output_plan =
+                Stage5InstructionReadRafEmitPlan::from_eval_families(&indexed_eval_families)?
+                    .relation_output_plan();
+            relation_output_values.extend(output_plan.relation_output_values);
+            for expr in output_plan.field_exprs {
+                if ScalarExprKind::from_cpu_attr(&expr.formula).is_ok() {
+                    scalar_exprs.push(stage5_scalar_expr(expr));
+                } else {
+                    field_exprs.push(stage5_field_expr(expr));
+                }
+            }
+            relation_outputs.push(output_plan.claim);
+        }
+        if role == Role::Verifier {
+            scalar_exprs.extend(
+                relation_output_values
+                    .iter()
+                    .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan)
+                    .map(stage5_relation_output_scalar_expr),
+            );
+        }
+
+        let mut program = Self {
             params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?,
-            role: module
-                .role()
-                .ok_or_else(|| EmitError::new("missing cpu party role"))?,
+            role,
+            verifier_plan: None,
+            indexed_eval_families,
             steps,
             transcript_squeezes,
             transcript_absorb_bytes,
             opening_inputs,
             field_constants,
             field_exprs,
+            scalar_exprs,
             kernels,
             claims,
             batches,
             drivers,
             instance_results,
             evals,
+            relation_output_values,
+            relation_output_eval_families,
+            relation_output_product_families,
+            relation_output_function_families,
+            relation_outputs,
             point_slices,
             point_concats,
             opening_claims,
             opening_equalities,
             opening_batches,
-        })
+        };
+        if is_verifier {
+            program.verifier_plan = Some(program.plan_verifier()?);
+        }
+        Ok(program)
+    }
+
+    fn plan_verifier(&self) -> Result<VerifierStagePlan, EmitError> {
+        verifier_plan::plan_verifier_stage_from_cpu_sources(self)
+    }
+
+    fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> {
+        self.verifier_plan
+            .as_ref()
+            .ok_or_else(|| EmitError::new("missing stage5 verifier plan"))
     }
 
     fn verify_supported_target(&self) -> Result<(), EmitError> {
@@ -538,13 +401,19 @@ impl Stage5CpuProgram {
         require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?;
         self.verify_transcript_steps()?;
         self.verify_field_flow()?;
-        self.verify_claim_batches()?;
         match self.role {
             Role::Prover => {
+                self.verify_claim_batches()?;
                 self.verify_kernel_definitions()?;
                 self.verify_prover_driver_bindings()?;
             }
-            Role::Verifier => self.verify_verifier_driver_bindings()?,
+            Role::Verifier => {
+                self.verifier_plan()?.verify_sumcheck_flow("stage5")?;
+                self.verify_verifier_driver_bindings()?;
+            }
+        }
+        if self.role == Role::Verifier {
+            self.verify_relation_outputs()?;
         }
         self.verify_opening_flow()
     }
@@ -582,23 +451,41 @@ impl Stage5CpuProgram {
         for constant in &self.field_constants {
             require_supported_symbol("field constant field", &constant.field, "bn254_fr")?;
         }
-        let field_values = self.field_value_symbols();
-        for expr in &self.field_exprs {
-            verify_count(
-                "field expr operands",
-                &expr.symbol,
-                expr.operand_names.len(),
-                expr.operands.len(),
-            )?;
-            for operand in &expr.operands {
-                if !field_values.contains(operand) {
-                    return Err(EmitError::new(format!(
-                        "field expr @{} references missing field value @{operand}",
-                        expr.symbol
-                    )));
-                }
-            }
-        }
+        let verifier_plan = if self.role == Role::Verifier {
+            Some(self.verifier_plan()?)
+        } else {
+            None
+        };
+        let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values());
+        let field_values = verifier_scalar_values.as_ref().map_or_else(
+            || self.cpu_field_value_sources(),
+            |values| values.source_set(),
+        );
+        let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values());
+        let verifier_point_values = verifier_plan.map(|plan| plan.point_values());
+        let point_values = verifier_point_values
+            .as_ref()
+            .map(|values| values.source_set());
+        super::plan_tokens::verify_field_expr_flow(
+            super::plan_tokens::FieldExprFlowVerification {
+                cpu_exprs: &self.field_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+            },
+        )?;
+        super::plan_tokens::verify_scalar_expr_flow(
+            super::plan_tokens::ScalarExprFlowVerification {
+                stage: "stage5",
+                cpu_exprs: &self.scalar_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+                field_vector_values: field_vector_values.as_ref(),
+                point_values: point_values.as_ref(),
+                verifier_point_values: verifier_point_values.as_ref(),
+            },
+        )?;
         for claim in &self.claims {
             if !field_values.contains(&claim.claim_value) {
                 return Err(EmitError::new(format!(
@@ -610,19 +497,59 @@ impl Stage5CpuProgram {
         Ok(())
     }
 
-    fn field_value_symbols(&self) -> BTreeSet<String> {
-        let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
-        values.extend(symbols(
+    fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet {
+        let mut values = verifier_values::VerifierScalarSourceSet::default();
+        values.extend(
+            self.opening_inputs.iter().map(|input| &input.symbol),
+            verifier_values::VerifierScalarSourceKind::OpeningInput,
+        );
+        values.extend(
             self.field_constants.iter().map(|constant| &constant.symbol),
-        ));
-        values.extend(symbols(
+            verifier_values::VerifierScalarSourceKind::FieldConstant,
+        );
+        values.extend(
             self.transcript_squeezes
                 .iter()
                 .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar"))
                 .map(|squeeze| &squeeze.symbol),
-        ));
-        values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol)));
-        values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol)));
+            verifier_values::VerifierScalarSourceKind::TranscriptScalar,
+        );
+        values.extend(
+            self.relation_output_eval_families
+                .iter()
+                .map(|family| &family.symbol),
+            verifier_values::VerifierScalarSourceKind::OutputEvalFamily,
+        );
+        values.extend(
+            self.relation_output_product_families
+                .iter()
+                .map(|family| &family.symbol),
+            verifier_values::VerifierScalarSourceKind::OutputProductFamily,
+        );
+        values.extend(
+            self.relation_output_function_families
+                .iter()
+                .map(|family| &family.symbol),
+            verifier_values::VerifierScalarSourceKind::OutputFunctionFamily,
+        );
+        values.extend(
+            self.field_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::FieldExpr,
+        );
+        values.extend(
+            self.scalar_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::ScalarExpr,
+        );
+        values.extend(
+            self.relation_outputs
+                .iter()
+                .flat_map(|claim| claim.local_scalar_symbols()),
+            verifier_values::VerifierScalarSourceKind::RelationOutputLocal,
+        );
+        values.extend(
+            self.evals.iter().map(|eval| &eval.symbol),
+            verifier_values::VerifierScalarSourceKind::SumcheckEval,
+        );
         values
     }
 
@@ -757,11 +684,6 @@ impl Stage5CpuProgram {
                 "verifier stage5 program must not contain kernels",
             ));
         }
-        let batches: BTreeMap<_, _> = self
-            .batches
-            .iter()
-            .map(|batch| (batch.symbol.as_str(), batch))
-            .collect();
         for claim in &self.claims {
             if claim.kernel.is_some() || claim.relation.is_none() {
                 return Err(EmitError::new(format!(
@@ -777,29 +699,18 @@ impl Stage5CpuProgram {
                     driver.symbol
                 )));
             }
-            let batch = batches.get(driver.batch.as_str()).ok_or_else(|| {
-                EmitError::new(format!(
-                    "sumcheck driver @{} references missing batch @{}",
-                    driver.symbol, driver.batch
-                ))
-            })?;
-            verify_count(
-                "sumcheck driver round_schedule",
-                &driver.symbol,
-                driver.num_rounds,
-                driver.round_schedule.iter().sum(),
-            )?;
-            if driver.round_schedule != batch.round_schedule {
-                return Err(EmitError::new(format!(
-                    "sumcheck driver @{} round_schedule differs from batch @{}",
-                    driver.symbol, batch.symbol
-                )));
-            }
         }
         Ok(())
     }
 
+    fn verify_relation_outputs(&self) -> Result<(), EmitError> {
+        self.verifier_plan()?.verify_relation_outputs("stage5")
+    }
+
     fn verify_opening_flow(&self) -> Result<(), EmitError> {
+        if self.role == Role::Verifier {
+            return self.verifier_plan()?.verify_opening_flow("stage5");
+        }
         let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol));
         point_sources.extend(symbols(
             self.instance_results
@@ -831,7 +742,7 @@ impl Stage5CpuProgram {
                 }
             }
         }
-        let eval_sources = self.field_value_symbols();
+        let eval_sources = self.cpu_field_value_sources();
         let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
         opening_sources.extend(symbols(
             self.opening_claims.iter().map(|claim| &claim.symbol),
@@ -930,7 +841,7 @@ impl Stage5CpuProgram {
         }
     }
 
-    fn emit_source(&self) -> String {
+    fn emit_source(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         source.push_str("#![allow(dead_code)]\n\n");
         match self.role {
@@ -946,10 +857,10 @@ impl Stage5CpuProgram {
             }
         }
         source.push('\n');
-        source.push_str(&self.emit_constants());
+        source.push_str(&self.emit_constants()?);
         source.push('\n');
         source.push_str(self.emit_entrypoint());
-        source
+        Ok(source)
     }
 
     fn emit_prover_imports() -> &'static str {
@@ -963,10 +874,9 @@ impl Stage5CpuProgram {
     }
 
     fn emit_verifier_imports() -> &'static str {
-        "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, identity_polynomial_eval, indexed_evals_by_prefix_any, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval, reverse_slice, suffix_point};\n\
-         use jolt_field::{Field, Fr, RingCore};\n\
-         use jolt_lookup_tables::LookupTableKind;\n\
-         use jolt_poly::EqPolynomial;\n\
+        "use bolt_verifier_runtime::find_plan;\n\
+         use super::jolt_relations::{evaluate_stage5_instruction_read_raf_local_scalars, normalize_instruction_read_raf_point, JoltLocalScalarMleKind, JoltLocalScalarPlan, Stage5InstructionReadRafPlan};\n\
+         use jolt_field::{Field, Fr};\n\
          use jolt_sumcheck::SumcheckError;\n\
          use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};"
     }
@@ -1177,26 +1087,36 @@ pub struct Stage5CpuProgramPlan {
     }
 
     fn emit_verifier_type_aliases() -> &'static str {
-        r#"pub type Stage5NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage5SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage5ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage5ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage5Proof<F> = super::common::StageProof<F>;
-pub type Stage5OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-
-pub use super::common::{
-    FieldConstantPlan as Stage5FieldConstantPlan, FieldExprPlan as Stage5FieldExprPlan,
+        r#"pub type Stage5NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage5SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage5ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage5ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage5Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage5OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan<Stage5RelationKind>;
+pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage5RelationKind>;
+pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage5RelationKind>;
+pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage5RelationKind>;
+pub type Stage5RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage5RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage5ClaimKind, FieldConstantPlan as Stage5FieldConstantPlan,
+    FieldExprKind as Stage5FieldExprKind,
+    FieldExprPlan as Stage5FieldExprPlan,
+    ScalarExprKind as Stage5ScalarExprKind,
+    ScalarExprPlan as Stage5ScalarExprPlan,
     KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan,
-    PointConcatPlan as Stage5PointConcatPlan, PointSlicePlan as Stage5PointSlicePlan,
+    OpeningEqualityMode as Stage5OpeningEqualityMode, PointExprKind as Stage5PointExprKind,
+    PointExprPlan as Stage5PointExprPlan,
+    ProgramStepKind as Stage5ProgramStepKind,
     ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params,
-    StageProgramPlanNoPointZeros as Stage5CpuProgramPlan,
     SumcheckBatchPlan as Stage5SumcheckBatchPlan,
-    SumcheckClaimPlan as Stage5SumcheckClaimPlan, SumcheckDriverPlan as Stage5SumcheckDriverPlan,
     SumcheckEvalPlan as Stage5SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage5SumcheckInstanceResultPlan,
     TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan,
+    TranscriptSqueezeKind as Stage5TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage5TranscriptSqueezePlan,
 };
 "#
@@ -1207,7 +1127,20 @@ pub use super::common::{
         source.push_str(
             r#"
 pub type DefaultStage5Transcript = Blake2bTranscript<Fr>;
-pub type Stage5VerifierProgramPlan = Stage5CpuProgramPlan;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage5VerifierProgramPlan {
+    pub base: Stage5CpuProgramPlan,
+    pub instruction_read_raf_plan: Stage5InstructionReadRafPlan,
+}
+
+impl core::ops::Deref for Stage5VerifierProgramPlan {
+    type Target = Stage5CpuProgramPlan;
+
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
+}
 
 #[derive(Debug)]
 pub enum VerifyStage5Error {
@@ -1218,116 +1151,184 @@ pub enum VerifyStage5Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage5RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error);
 "#,
         );
         source
     }
 
-    fn emit_constants(&self) -> String {
-        let mut source = self.emit_shared_constants();
+    fn emit_constants(&self) -> Result<String, EmitError> {
+        let mut source = self.emit_shared_constants()?;
         source.push_str(&self.emit_kernel_constants());
-        source.push_str(&self.emit_sumcheck_claim_constants());
-        source.push_str(&self.emit_sumcheck_batch_constants());
-        source.push_str(&self.emit_sumcheck_driver_constants());
-        source.push_str(&self.emit_tail_constants());
+        source.push_str(&self.emit_sumcheck_claim_constants()?);
+        source.push_str(&self.emit_sumcheck_batch_constants()?);
+        source.push_str(&self.emit_sumcheck_driver_constants()?);
+        source.push_str(&self.emit_tail_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_indexed_eval_family_constants()?);
+            source.push_str(&self.emit_verifier_relation_output_constants()?);
+        }
+        let program_field_indent = if self.role == Role::Verifier {
+            "        "
+        } else {
+            "    "
+        };
+        let relation_outputs_field = if self.role == Role::Verifier {
+            format!("{program_field_indent}relation_outputs: STAGE5_RELATION_OUTPUTS,\n")
+        } else {
+            String::new()
+        };
+        let indexed_eval_families_field = if self.role == Role::Verifier {
+            format!("{program_field_indent}indexed_eval_families: STAGE5_INDEXED_EVAL_FAMILIES,\n")
+        } else {
+            String::new()
+        };
+        let scalar_exprs_field = if self.role == Role::Verifier {
+            format!("{program_field_indent}scalar_exprs: STAGE5_SCALAR_EXPRS,\n")
+        } else {
+            String::new()
+        };
+        let point_exprs_field = if self.role == Role::Verifier {
+            format!("{program_field_indent}point_exprs: STAGE5_POINT_EXPRS,\n")
+        } else {
+            format!("{program_field_indent}point_slices: STAGE5_POINT_SLICES,\n{program_field_indent}point_concats: STAGE5_POINT_CONCATS,\n")
+        };
+        let program_constructor = if self.role == Role::Verifier {
+            "Stage5VerifierProgramPlan {\n    base: Stage5CpuProgramPlan {"
+        } else {
+            "Stage5CpuProgramPlan {"
+        };
+        let verifier_program_fields = if self.role == Role::Verifier {
+            "    },\n    instruction_read_raf_plan: STAGE5_INSTRUCTION_READ_RAF_PLAN,\n"
+        } else {
+            ""
+        };
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE5_PROGRAM: {} = Stage5CpuProgramPlan {{\n\
-                 \x20   role: {},\n\
-                 \x20   params: STAGE5_PARAMS,\n\
-                 \x20   steps: STAGE5_PROGRAM_STEPS,\n\
-                 \x20   transcript_squeezes: STAGE5_TRANSCRIPT_SQUEEZES,\n\
-                 \x20   transcript_absorb_bytes: STAGE5_TRANSCRIPT_ABSORB_BYTES,\n\
-                 \x20   opening_inputs: STAGE5_OPENING_INPUTS,\n\
-                 \x20   field_constants: STAGE5_FIELD_CONSTANTS,\n\
-                 \x20   field_exprs: STAGE5_FIELD_EXPRS,\n\
-                 \x20   kernels: STAGE5_KERNELS,\n\
-                 \x20   claims: STAGE5_SUMCHECK_CLAIMS,\n\
-                 \x20   batches: STAGE5_SUMCHECK_BATCHES,\n\
-                 \x20   drivers: STAGE5_SUMCHECK_DRIVERS,\n\
-                 \x20   instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,\n\
-                 \x20   evals: STAGE5_SUMCHECK_EVALS,\n\
-                 \x20   point_slices: STAGE5_POINT_SLICES,\n\
-                 \x20   point_concats: STAGE5_POINT_CONCATS,\n\
-                 \x20   opening_claims: STAGE5_OPENING_CLAIMS,\n\
-                 \x20   opening_equalities: STAGE5_OPENING_EQUALITIES,\n\
-                 \x20   opening_batches: STAGE5_OPENING_BATCHES,\n\
+                "pub const STAGE5_PROGRAM: {} = {program_constructor}\n\
+                 {program_field_indent}role: {},\n\
+                 {program_field_indent}params: STAGE5_PARAMS,\n\
+                 {program_field_indent}steps: STAGE5_PROGRAM_STEPS,\n\
+                 {program_field_indent}transcript_squeezes: STAGE5_TRANSCRIPT_SQUEEZES,\n\
+                 {program_field_indent}transcript_absorb_bytes: STAGE5_TRANSCRIPT_ABSORB_BYTES,\n\
+                 {program_field_indent}opening_inputs: STAGE5_OPENING_INPUTS,\n\
+                 {program_field_indent}field_constants: STAGE5_FIELD_CONSTANTS,\n\
+                 {program_field_indent}field_exprs: STAGE5_FIELD_EXPRS,\n\
+                 {scalar_exprs_field}\
+                 {program_field_indent}kernels: STAGE5_KERNELS,\n\
+                 {program_field_indent}claims: STAGE5_SUMCHECK_CLAIMS,\n\
+                 {program_field_indent}batches: STAGE5_SUMCHECK_BATCHES,\n\
+                 {program_field_indent}drivers: STAGE5_SUMCHECK_DRIVERS,\n\
+                 {program_field_indent}instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,\n\
+                 {program_field_indent}evals: STAGE5_SUMCHECK_EVALS,\n\
+                 {indexed_eval_families_field}\
+                 {relation_outputs_field}\
+                 {point_exprs_field}\
+                 {program_field_indent}opening_claims: STAGE5_OPENING_CLAIMS,\n\
+                 {program_field_indent}opening_equalities: STAGE5_OPENING_EQUALITIES,\n\
+                 {program_field_indent}opening_batches: STAGE5_OPENING_BATCHES,\n\
+                 {verifier_program_fields}\
                  }};\n",
                 self.program_plan_type(),
                 rust_str(self.role_label())
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_shared_constants(&self) -> String {
+    fn emit_shared_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE5_PARAMS: Stage5Params = Stage5Params {{\n\
-                 \x20   field: {},\n\
-                 \x20   pcs: {},\n\
-                 \x20   transcript: {},\n\
-                 }};\n",
+                "pub const STAGE5_PARAMS: Stage5Params = Stage5Params {{ field: {}, pcs: {}, transcript: {} }};\n",
                 rust_str(&self.params.field),
                 rust_str(&self.params.pcs),
                 rust_str(&self.params.transcript)
             ),
         );
-        source.push_str(&self.emit_program_step_constants());
-        source.push_str(&self.emit_transcript_squeeze_constants());
-        source.push_str(&self.emit_transcript_absorb_bytes_constants());
-        source.push_str(&self.emit_opening_input_constants());
+        source.push_str(&self.emit_program_step_constants()?);
+        source.push_str(&self.emit_transcript_squeeze_constants()?);
+        source.push_str(&self.emit_transcript_absorb_bytes_constants()?);
+        source.push_str(&self.emit_opening_input_constants()?);
         source.push_str(&self.emit_field_constant_constants());
-        source.push_str(&self.emit_field_expr_constants());
-        source
+        source.push_str(&self.emit_field_expr_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_scalar_expr_constants()?);
+        }
+        Ok(source)
     }
 
-    fn emit_program_step_constants(&self) -> String {
+    fn emit_program_step_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_program_step_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.steps,
+            ));
+        }
         let steps = self
             .steps
             .iter()
             .map(|step| {
-                format!(
+                Ok(format!(
                     "    Stage5ProgramStepPlan {{ kind: {}, symbol: {} }},",
-                    rust_str(&step.kind),
+                    super::plan_tokens::role_program_step_kind_expr(
+                        "Stage5", &self.role, &step.kind
+                    )?,
                     rust_str(&step.symbol),
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE5_PROGRAM_STEPS: &[Stage5ProgramStepPlan] = &[\n{steps}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE5_PROGRAM_STEPS: &[Stage5ProgramStepPlan] = &[\n{steps}\n];\n\n"
+        ))
     }
 
-    fn emit_transcript_squeeze_constants(&self) -> String {
+    fn emit_transcript_squeeze_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_transcript_squeeze_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.transcript_squeezes,
+            ));
+        }
         let squeezes = self
             .transcript_squeezes
             .iter()
             .map(|squeeze| {
-                format!(
+                Ok(format!(
                     "    Stage5TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},",
                     rust_str(&squeeze.symbol),
                     rust_str(&squeeze.label),
-                    rust_str(&squeeze.kind),
+                    super::plan_tokens::role_transcript_squeeze_kind_expr("Stage5", &self.role, &squeeze.kind)?,
                     squeeze.count,
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE5_TRANSCRIPT_SQUEEZES: &[Stage5TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_transcript_absorb_bytes_constants(&self) -> String {
+    fn emit_transcript_absorb_bytes_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_transcript_absorb_bytes_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.transcript_absorb_bytes,
+            ));
+        }
         let absorbs = self
             .transcript_absorb_bytes
             .iter()
@@ -1341,17 +1342,25 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE5_TRANSCRIPT_ABSORB_BYTES: &[Stage5TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_opening_input_constants(&self) -> String {
+    fn emit_opening_input_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_input_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.opening_inputs,
+            ));
+        }
         let inputs = self
             .opening_inputs
             .iter()
             .map(|input| {
-                format!(
+                Ok(format!(
                     "    Stage5OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},",
                     rust_str(&input.symbol),
                     rust_str(&input.source_stage),
@@ -1359,12 +1368,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
                     rust_str(&input.oracle),
                     rust_str(&input.domain),
                     input.point_arity,
-                    rust_str(&input.claim_kind)
-                )
+                    super::plan_tokens::role_claim_kind_expr("Stage5", &self.role, &input.claim_kind)?
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE5_OPENING_INPUTS: &[Stage5OpeningInputPlan] = &[\n{inputs}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE5_OPENING_INPUTS: &[Stage5OpeningInputPlan] = &[\n{inputs}\n];\n\n"
+        ))
     }
 
     fn emit_field_constant_constants(&self) -> String {
@@ -1386,25 +1397,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
         )
     }
 
-    fn emit_field_expr_constants(&self) -> String {
+    fn emit_field_expr_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let exprs = self
-                .field_exprs
-                .iter()
-                .map(|expr| {
-                    format!(
-                        "    Stage5FieldExprPlan {{ symbol: {}, kind: {}, formula: {}, operands: {} }},",
-                        rust_str(&expr.symbol),
-                        rust_str(&expr.kind),
-                        rust_str(&expr.formula),
-                        rust_str(&expr.operands.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[\n{exprs}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_field_expr_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.field_exprs,
+            ));
         }
 
         let mut source = String::new();
@@ -1446,7 +1446,16 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
                 "pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[\n{exprs}\n];\n"
             ),
         );
-        source
+        Ok(source)
+    }
+
+    fn emit_scalar_expr_constants(&self) -> Result<String, EmitError> {
+        let plan = self.verifier_plan()?;
+        Ok(verifier_plan::emit_scalar_expr_constants(
+            "Stage5",
+            "STAGE5",
+            &plan.scalar_exprs,
+        ))
     }
 
     fn emit_kernel_constants(&self) -> String {
@@ -1468,31 +1477,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
         format!("pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[\n{kernels}\n];\n\n")
     }
 
-    fn emit_sumcheck_claim_constants(&self) -> String {
+    fn emit_sumcheck_claim_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let claims = self
-                .claims
-                .iter()
-                .map(|claim| {
-                    format!(
-                        "    Stage5SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},",
-                        rust_str(&claim.symbol),
-                        rust_str(&claim.stage),
-                        rust_str(&claim.domain),
-                        claim.num_rounds,
-                        claim.degree,
-                        rust_str(&claim.claim),
-                        rust_option_str(claim.kernel.as_deref()),
-                        rust_option_str(claim.relation.as_deref()),
-                        rust_str(&claim.claim_value),
-                        rust_str(&claim.input_openings.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[\n{claims}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_claim_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.claims,
+            ));
         }
 
         let mut source = String::new();
@@ -1507,7 +1499,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
             .iter()
             .enumerate()
             .map(|(index, claim)| {
-                format!(
+                Ok(format!(
                     "    Stage5SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: STAGE5_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.stage),
@@ -1516,11 +1508,15 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
                     claim.degree,
                     rust_str(&claim.claim),
                     rust_option_str(claim.kernel.as_deref()),
-                    rust_option_str(claim.relation.as_deref()),
+                    super::plan_tokens::role_optional_relation_kind_expr(
+                        "Stage5",
+                        &self.role,
+                        claim.relation.as_deref()
+                    )?,
                     rust_str(&claim.claim_value)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
         push_format(
             &mut source,
@@ -1528,45 +1524,17 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
                 "pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[\n{claims}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_sumcheck_batch_constants(&self) -> String {
+    fn emit_sumcheck_batch_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let mut source = String::new();
-            for (index, batch) in self.batches.iter().enumerate() {
-                source.push_str(&emit_usize_array(
-                    &format!("STAGE5_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"),
-                    &batch.round_schedule,
-                ));
-            }
-            let batches = self
-                .batches
-                .iter()
-                .enumerate()
-                .map(|(index, batch)| {
-                    format!(
-                        "    Stage5SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE5_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
-                        rust_str(&batch.symbol),
-                        rust_str(&batch.stage),
-                        rust_str(&batch.proof_slot),
-                        rust_str(&batch.policy),
-                        batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|")),
-                        rust_str(&batch.claim_label),
-                        rust_str(&batch.round_label)
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            push_format(
-                &mut source,
-                format_args!(
-                    "pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[\n{batches}\n];\n"
-                ),
-            );
-            return source;
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_batch_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.batches,
+            ));
         }
 
         let mut source = String::new();
@@ -1608,10 +1576,18 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
                 "pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[\n{batches}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_sumcheck_driver_constants(&self) -> String {
+    fn emit_sumcheck_driver_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_driver_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.drivers,
+            ));
+        }
         let mut source = String::new();
         for (index, driver) in self.drivers.iter().enumerate() {
             source.push_str(&emit_usize_array(
@@ -1624,22 +1600,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
             .iter()
             .enumerate()
             .map(|(index, driver)| {
-                format!(
+                Ok(format!(
                     "    Stage5SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: {}, relation: {}, batch: {}, policy: {}, round_schedule: STAGE5_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},",
                     rust_str(&driver.symbol),
                     rust_str(&driver.stage),
                     rust_str(&driver.proof_slot),
                     rust_option_str(driver.kernel.as_deref()),
-                    rust_option_str(driver.relation.as_deref()),
+                    super::plan_tokens::role_optional_relation_kind_expr(
+                        "Stage5",
+                        &self.role,
+                        driver.relation.as_deref()
+                    )?,
                     rust_str(&driver.batch),
                     rust_str(&driver.policy),
                     rust_str(&driver.claim_label),
                     rust_str(&driver.round_label),
                     driver.num_rounds,
                     driver.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
         push_format(
             &mut source,
@@ -1647,45 +1627,62 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
                 "pub const STAGE5_SUMCHECK_DRIVERS: &[Stage5SumcheckDriverPlan] = &[\n{drivers}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_tail_constants(&self) -> String {
+    fn emit_tail_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
-        source.push_str(&self.emit_sumcheck_instance_result_constants());
+        source.push_str(&self.emit_sumcheck_instance_result_constants()?);
         source.push_str(&self.emit_sumcheck_eval_constants());
-        source.push_str(&self.emit_point_slice_constants());
-        source.push_str(&self.emit_point_concat_constants());
-        source.push_str(&self.emit_opening_claim_constants());
-        source.push_str(&self.emit_opening_claim_equality_constants());
-        source.push_str(&self.emit_opening_batch_constants());
-        source
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_named_eval_family_constants()?);
+        }
+        source.push_str(&self.emit_point_constants()?);
+        source.push_str(&self.emit_opening_claim_constants()?);
+        source.push_str(&self.emit_opening_claim_equality_constants()?);
+        source.push_str(&self.emit_opening_batch_constants()?);
+        Ok(source)
     }
 
-    fn emit_sumcheck_instance_result_constants(&self) -> String {
+    fn emit_sumcheck_instance_result_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_instance_result_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.instance_results,
+            ));
+        }
         let instances = self
             .instance_results
             .iter()
             .map(|instance| {
-                format!(
+                Ok(format!(
                     "    Stage5SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},",
                     rust_str(&instance.symbol),
                     rust_str(&instance.source),
                     rust_str(&instance.claim),
-                    rust_str(&instance.relation),
+                    super::plan_tokens::role_relation_kind_expr(
+                        "Stage5",
+                        &self.role,
+                        &instance.relation
+                    )?,
                     instance.index,
                     instance.point_arity,
                     instance.num_rounds,
                     instance.round_offset,
-                    rust_str(&instance.point_order),
+                    super::plan_tokens::role_sumcheck_point_order_expr(
+                        &self.role,
+                        &instance.point_order
+                    )?,
                     instance.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE5_SUMCHECK_INSTANCE_RESULTS: &[Stage5SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n"
-        )
+        ))
     }
 
     fn emit_sumcheck_eval_constants(&self) -> String {
@@ -1707,7 +1704,42 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
         format!("pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[\n{evals}\n];\n\n")
     }
 
-    fn emit_point_slice_constants(&self) -> String {
+    fn emit_indexed_eval_family_constants(&self) -> Result<String, EmitError> {
+        Ok(verifier_eval_families::emit_named_runtime_slice_constant(
+            &self.verifier_plan()?.indexed_eval_families,
+            "pub ",
+            "STAGE5_INDEXED_EVAL_FAMILY",
+            "STAGE5_INDEXED_EVAL_FAMILIES",
+        ))
+    }
+
+    fn emit_named_eval_family_constants(&self) -> Result<String, EmitError> {
+        Ok(self
+            .verifier_plan()?
+            .relation_local_inputs
+            .stage5_instruction_read_raf()?
+            .emit_runtime_constants())
+    }
+
+    fn emit_verifier_relation_output_constants(&self) -> Result<String, EmitError> {
+        super::relation_outputs::emit_verifier_relation_output_constants(
+            "Stage5",
+            &self.role,
+            &self.relation_outputs,
+        )
+    }
+
+    fn emit_point_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_point_expr_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.point_exprs,
+            ));
+        }
+
+        let mut source = String::new();
         let slices = self
             .point_slices
             .iter()
@@ -1723,31 +1755,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!("pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[\n{slices}\n];\n\n")
-    }
-
-    fn emit_point_concat_constants(&self) -> String {
-        if self.role == Role::Verifier {
-            let concats = self
-                .point_concats
-                .iter()
-                .map(|concat| {
-                    format!(
-                        "    Stage5PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},",
-                        rust_str(&concat.symbol),
-                        rust_str(&concat.layout),
-                        concat.arity,
-                        rust_str(&concat.inputs.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE5_POINT_CONCATS: &[Stage5PointConcatPlan] = &[\n{concats}\n];\n"
-            );
-        }
-
-        let mut source = String::new();
+        push_format(
+            &mut source,
+            format_args!(
+                "pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[\n{slices}\n];\n\n"
+            ),
+        );
         for (index, concat) in self.point_concats.iter().enumerate() {
             source.push_str(&emit_str_array(
                 &format!("STAGE5_POINT_CONCAT_{index}_INPUTS"),
@@ -1774,72 +1787,76 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
                 "pub const STAGE5_POINT_CONCATS: &[Stage5PointConcatPlan] = &[\n{concats}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_opening_claim_constants(&self) -> String {
+    fn emit_opening_claim_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.opening_claims,
+            ));
+        }
         let claims = self
             .opening_claims
             .iter()
             .map(|claim| {
-                format!(
+                Ok(format!(
                     "    Stage5OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.oracle),
                     rust_str(&claim.domain),
                     claim.point_arity,
-                    rust_str(&claim.claim_kind),
+                    super::plan_tokens::role_claim_kind_expr("Stage5", &self.role, &claim.claim_kind)?,
                     rust_str(&claim.point_source),
                     rust_str(&claim.eval_source)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE5_OPENING_CLAIMS: &[Stage5OpeningClaimPlan] = &[\n{claims}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE5_OPENING_CLAIMS: &[Stage5OpeningClaimPlan] = &[\n{claims}\n];\n\n"
+        ))
     }
 
-    fn emit_opening_claim_equality_constants(&self) -> String {
+    fn emit_opening_claim_equality_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_equality_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.opening_equalities,
+            ));
+        }
         let equalities = self
             .opening_equalities
             .iter()
             .map(|equality| {
-                format!(
+                Ok(format!(
                     "    Stage5OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},",
                     rust_str(&equality.symbol),
-                    rust_str(&equality.mode),
+                    super::plan_tokens::role_opening_equality_mode_expr("Stage5", &self.role, &equality.mode)?,
                     rust_str(&equality.lhs),
                     rust_str(&equality.rhs)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE5_OPENING_EQUALITIES: &[Stage5OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_opening_batch_constants(&self) -> String {
+    fn emit_opening_batch_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let batches = self
-                .opening_batches
-                .iter()
-                .map(|batch| {
-                    format!(
-                        "    Stage5OpeningBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {} }},",
-                        rust_str(&batch.symbol),
-                        rust_str(&batch.stage),
-                        rust_str(&batch.proof_slot),
-                        rust_str(&batch.policy),
-                        batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE5_OPENING_BATCHES: &[Stage5OpeningBatchPlan] = &[\n{batches}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_batch_constants(
+                "Stage5",
+                "STAGE5",
+                &plan.opening_batches,
+            ));
         }
 
         let mut source = String::new();
@@ -1875,7 +1892,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
                 "pub const STAGE5_OPENING_BATCHES: &[Stage5OpeningBatchPlan] = &[\n{batches}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
     fn emit_entrypoint(&self) -> &'static str {
@@ -1932,19 +1949,19 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
     let mut artifacts = Stage5ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage5ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage5Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage5_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "transcript_absorb_bytes" => {
+            Stage5ProgramStepKind::TranscriptAbsorbBytes => {
                 let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or(
                     VerifyStage5Error::MissingValue {
                         symbol: step.symbol,
@@ -1952,19 +1969,13 @@ where
                 )?;
                 absorb_stage5_bytes(absorb, transcript);
             }
-            "sumcheck_driver" => {
+            Stage5ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage5Error::MissingProof {
                         driver: step.symbol,
                     })?;
                 verify_stage5_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?;
             }
-            _ => {
-                return Err(VerifyStage5Error::InvalidProof {
-                    driver: step.symbol,
-                    reason: "unsupported stage5 program step",
-                });
-            }
         }
     }
     artifacts
@@ -1980,7 +1991,7 @@ pub fn stage5_verifier_program() -> &'static Stage5VerifierProgramPlan {
 fn verify_stage5_squeeze<T>(
     program: &'static Stage5VerifierProgramPlan,
     squeeze: &'static Stage5TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage5ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage5Error>
@@ -1996,7 +2007,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage5Error::from)?;
     artifacts.challenge_vectors.push(Stage5ChallengeVector {
         symbol: squeeze.symbol,
@@ -2020,7 +2031,7 @@ fn verify_stage5_driver<T>(
     program: &'static Stage5VerifierProgramPlan,
     driver: &'static Stage5SumcheckDriverPlan,
     proof: &Stage5Proof<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage5ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage5Error>
@@ -2033,12 +2044,17 @@ where
         .ok_or(VerifyStage5Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage5Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage5.batched" => {
+        Stage5RelationKind::Stage5Batched => {
             verify_batched_stage5(program, driver, proof, store, transcript)?
         }
-        _ => return Err(VerifyStage5Error::UnsupportedRelation { relation }),
+        relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -2048,25 +2064,50 @@ fn verify_batched_stage5<T>(
     program: &'static Stage5VerifierProgramPlan,
     driver: &'static Stage5SumcheckDriverPlan,
     proof: &Stage5SumcheckOutput<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage5SumcheckOutput<Fr>, VerifyStage5Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage5Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs)
+            bolt_verifier_runtime::evaluate_relation_output_batch(
+                driver,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                program.indexed_eval_families,
+                store,
+                evals,
+                point,
+                batching_coeffs,
+                |instance, relation_output, local_point| {
+                    stage5_relation_output_inputs(program, instance, relation_output, local_point)
+                },
+            )
         },
         |store, verified| observe_stage5_sumcheck_output(program, store, verified),
         |driver, error| VerifyStage5Error::Sumcheck { driver, error },
@@ -2075,7 +2116,7 @@ where
 
 fn observe_stage5_sumcheck_output<F: Field>(
     program: &'static Stage5VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage5SumcheckOutput<F>,
 ) -> Result<(), VerifyStage5Error> {
     store.observe_sumcheck_output(
@@ -2084,17 +2125,17 @@ fn observe_stage5_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                "instruction_read_raf" => {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
+                    if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf {
+                        return Err(VerifyStage5Error::InvalidProof {
+                            driver: output.driver,
+                            reason: "unsupported relation-local point order",
+                        });
+                    }
                     point = normalize_instruction_read_raf_point(&point, "stage5.instruction_read_raf.point")?;
                 }
-                _ => {
-                    return Err(VerifyStage5Error::InvalidProof {
-                        driver: output.driver,
-                        reason: "unsupported point order",
-                    });
-                }
             }
             Ok(point)
         },
@@ -2105,9 +2146,9 @@ fn observe_stage5_sumcheck_output<F: Field>(
         },
         |symbol| VerifyStage5Error::MissingValue { symbol },
     )?;
+    store.evaluate_named_eval_families(program.indexed_eval_families)?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage5Error::InvalidInputLength {
             input,
             expected,
@@ -2115,7 +2156,7 @@ fn observe_stage5_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage5Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -2124,154 +2165,26 @@ fn observe_stage5_sumcheck_output<F: Field>(
     )
 }
 
-fn expected_batched_output_claim(
+fn stage5_relation_output_inputs<'a>(
     program: &'static Stage5VerifierProgramPlan,
-    driver: &'static Stage5SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage5NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage5Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage5Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage5Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let relation = claim.relation.unwrap_or("<missing>");
-        let value = match relation {
-            "jolt.stage5.instruction_read_raf" => {
-                expected_instruction_read_raf(store, evals, local_point)?
-            }
-            "jolt.stage5.ram_ra_claim_reduction" => {
-                expected_ram_ra_claim_reduction(store, evals, local_point)?
-            }
-            "jolt.stage5.registers_val_evaluation" => {
-                expected_registers_val_evaluation(store, evals, local_point)?
-            }
-            _ => return Err(VerifyStage5Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_instruction_read_raf(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage5NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage5Error> {
-    const LOG_K: usize = 128;
-    const XLEN: usize = 64;
-
-    if local_point.len() < LOG_K {
-        return Err(VerifyStage5Error::InvalidInputLength {
-            input: "stage5.instruction_read_raf.point",
-            expected: LOG_K,
-            actual: local_point.len(),
-        });
+    instance: &Stage5SumcheckInstanceResultPlan,
+    relation_output: &Stage5RelationOutputPlan,
+    local_point: &'a [Fr],
+) -> Result<bolt_verifier_runtime::RelationOutputInputs<'a, Fr>, VerifyStage5Error> {
+    if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf {
+        return Ok(bolt_verifier_runtime::RelationOutputInputs::empty());
     }
 
-    let (r_address_prime, r_cycle) = local_point.split_at(LOG_K);
-    let r_cycle_prime = reverse_slice(r_cycle);
-    let r_reduction = super::common::store_point(store, "stage5.input.stage2.instruction.LookupOutput")?;
-    let eq_eval_r_reduction = EqPolynomial::<Fr>::mle(r_reduction, &r_cycle_prime);
-
-    let left_operand_eval = operand_polynomial_eval(r_address_prime, true);
-    let right_operand_eval = operand_polynomial_eval(r_address_prime, false);
-    let identity_poly_eval = identity_polynomial_eval(r_address_prime);
-
-    let table_flag_claims = indexed_evals_by_prefix_any(
-        evals,
-        "stage5.instruction_read_raf.eval.LookupTableFlag_",
-    )?;
-    let table_values = LookupTableKind::<XLEN>::all()
-        .iter()
-        .take(table_flag_claims.len())
-        .map(|table| table.evaluate_mle::<Fr, Fr>(r_address_prime))
-        .collect::<Vec<_>>();
-    let val_claim = table_values
-        .into_iter()
-        .zip(table_flag_claims)
-        .map(|(table_value, flag_claim)| table_value * flag_claim)
-        .sum::<Fr>();
-
-    let ra_claim = indexed_evals_by_prefix_any(
-        evals,
-        "stage5.instruction_read_raf.eval.InstructionRa_",
-    )?
-    .into_iter()
-    .product::<Fr>();
-    let raf_flag_claim = eval_by_name(
-        evals,
-        "stage5.instruction_read_raf.eval.InstructionRafFlag",
-    )?;
-    let gamma = super::common::store_scalar(store, "stage5.instruction_read_raf.gamma")?;
-
-    let raf_claim = (Fr::from_u64(1) - raf_flag_claim)
-        * (left_operand_eval + gamma * right_operand_eval)
-        + raf_flag_claim * gamma * identity_poly_eval;
-    Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim))
-}
-
-fn expected_ram_ra_claim_reduction(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage5NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage5Error> {
-    let r_cycle_reduced = reverse_slice(local_point);
-    let r_cycle_raf = suffix_point(
-        super::common::store_point(store, "stage5.input.stage2.ram_raf.RamRa")?,
-        r_cycle_reduced.len(),
-        "stage5.input.stage2.ram_raf.RamRa",
-    )?;
-    let r_cycle_rw = suffix_point(
-        super::common::store_point(store, "stage5.input.stage2.ram_read_write.RamRa")?,
-        r_cycle_reduced.len(),
-        "stage5.input.stage2.ram_read_write.RamRa",
-    )?;
-    let r_cycle_val = suffix_point(
-        super::common::store_point(store, "stage5.input.stage4.ram_val_check.RamRa")?,
-        r_cycle_reduced.len(),
-        "stage5.input.stage4.ram_val_check.RamRa",
-    )?;
-    let gamma = super::common::store_scalar(store, "stage5.ram_ra_claim_reduction.gamma")?;
-    let eq_combined = EqPolynomial::<Fr>::mle(r_cycle_raf, &r_cycle_reduced)
-        + gamma * EqPolynomial::<Fr>::mle(r_cycle_rw, &r_cycle_reduced)
-        + gamma.square() * EqPolynomial::<Fr>::mle(r_cycle_val, &r_cycle_reduced);
-    let ram_ra = eval_by_name(evals, "stage5.ram_ra_claim_reduction.eval.RamRa")?;
-    Ok(eq_combined * ram_ra)
-}
-
-fn expected_registers_val_evaluation(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage5NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage5Error> {
-    let registers_val_point = super::common::store_point(store, "stage5.input.stage4.registers.RegistersVal")?;
-    let r_cycle = suffix_point(
-        registers_val_point,
-        local_point.len(),
-        "stage5.input.stage4.registers.RegistersVal",
-    )?;
-    let r_reduced = reverse_slice(local_point);
-    let lt_eval = lt_polynomial_eval(&r_reduced, r_cycle);
-    let rd_inc = eval_by_name(evals, "stage5.registers_val_evaluation.eval.RdInc")?;
-    let rd_wa = eval_by_name(evals, "stage5.registers_val_evaluation.eval.RdWa")?;
-    Ok(rd_inc * rd_wa * lt_eval)
+    Ok(bolt_verifier_runtime::RelationOutputInputs {
+        scalars: bolt_verifier_runtime::select_named_scalars(
+            relation_output.local_scalars,
+            evaluate_stage5_instruction_read_raf_local_scalars(
+                &program.instruction_read_raf_plan,
+                local_point,
+            )?,
+        )?,
+        points: Vec::new(),
+    })
 }
 
 "#
@@ -2322,10 +2235,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String {
 fn emit_usize_array(name: &str, values: &[usize]) -> String {
     let entries = values
         .iter()
-        .map(|value| format!("    {value},"))
+        .map(usize::to_string)
         .collect::<Vec<_>>()
-        .join("\n");
-    format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n")
+        .join(", ");
+    format!("pub const {name}: &[usize] = &[{entries}];\n\n")
 }
 
 fn intern_str_array(
@@ -2370,120 +2283,3 @@ fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Res
 fn symbols<'a>(values: impl Iterator<Item = &'a String>) -> BTreeSet<String> {
     values.cloned().collect()
 }
-
-fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(string_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "string"))
-}
-
-fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(symbol_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "symbol"))
-}
-
-fn symbol_array_attr(
-    operation: OperationRef<'_, '_>,
-    attr: &str,
-) -> Result<Vec<String>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "symbol array"))?;
-    parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array"))
-}
-
-fn parse_symbol_array(attribute: &str) -> Option<Vec<String>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
-    }
-    inner
-        .split(',')
-        .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned))
-        .collect()
-}
-
-fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<usize, EmitError> {
-    operation
-        .attribute(attr)
-        .map(parse_integer_attr)
-        .ok()
-        .flatten()
-        .ok_or_else(|| attr_error(operation, attr, "integer"))
-}
-
-fn parse_integer_attr(attribute: Attribute<'_>) -> Option<usize> {
-    attribute
-        .to_string()
-        .split_whitespace()
-        .next()
-        .and_then(|value| value.parse().ok())
-}
-
-fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<Vec<usize>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "integer array"))?;
-    parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array"))
-}
-
-fn parse_int_array(attribute: &str) -> Option<Vec<usize>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
-    }
-    inner
-        .split(',')
-        .map(|item| item.trim().parse().ok())
-        .collect()
-}
-
-fn operand_symbols(
-    operation: OperationRef<'_, '_>,
-    start_index: usize,
-) -> Result<Vec<String>, EmitError> {
-    (start_index..operation.operand_count())
-        .map(|index| operand_symbol(operation, index))
-        .collect()
-}
-
-fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result<String, EmitError> {
-    let operand = operation.operand(index).map_err(|_| {
-        EmitError::new(format!(
-            "{} requires operand {index}",
-            operation_name(operation)
-        ))
-    })?;
-    let owner = OperationResult::try_from(operand).map_err(|_| {
-        EmitError::new(format!(
-            "{} operand {index} must be an op result",
-            operation_name(operation)
-        ))
-    })?;
-    string_attr(owner.owner(), "sym_name")
-}
-
-fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError {
-    EmitError::new(format!(
-        "{} attr `{attr}` is not a {expected}",
-        operation_name(operation)
-    ))
-}
-
-fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String {
-    operation
-        .name()
-        .as_string_ref()
-        .as_str()
-        .unwrap_or("<invalid-operation-name>")
-        .to_owned()
-}
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs
index 191bee1f2c..1b2d2b15eb 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs
@@ -3,38 +3,95 @@
     reason = "generated Rust templates are kept as raw string blocks for copyable output"
 )]
 
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeMap;
 
 use melior::ir::block::BlockLike;
-use melior::ir::operation::{OperationLike, OperationResult};
-use melior::ir::{Attribute, OperationRef};
+use melior::ir::operation::OperationLike;
 
 use crate::emit::rust::{push_format, EmitError, RustSourceFile};
-use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role};
+use crate::ir::{BoltModule, Cpu, Role};
+use crate::protocols::jolt::cpu_attrs::{
+    operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr,
+};
+use crate::protocols::jolt::rust_target_plan::ScalarExprKind;
+use crate::protocols::jolt::stage6_bytecode_read_raf_plan::Stage6BytecodeReadRafEmitPlan;
+use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan};
+use crate::protocols::jolt::verifier_opening_rows;
+use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan};
+use crate::protocols::jolt::verifier_point_rows;
+use crate::protocols::jolt::verifier_program_rows;
+use crate::protocols::jolt::verifier_relation_outputs::{
+    self, parse_output_eval_family_plan, parse_output_function_family_plan,
+    parse_output_product_family_plan, RelationOutputAst as Stage6RelationOutputAst,
+    RelationOutputEvalFamilyPlan as Stage6RelationOutputEvalFamilyPlan,
+    RelationOutputFieldExprPlan as Stage6RelationOutputFieldExprPlan,
+    RelationOutputFunctionFamilyPlan as Stage6RelationOutputFunctionFamilyPlan,
+    RelationOutputPlan as Stage6RelationOutputPlan,
+    RelationOutputProductFamilyPlan as Stage6RelationOutputProductFamilyPlan,
+    StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan,
+};
+use crate::protocols::jolt::verifier_sumcheck_rows;
+use crate::protocols::jolt::verifier_value_rows;
+use crate::protocols::jolt::verifier_values;
 use crate::schema::verify_cpu_schema;
 
+use super::plan_tokens::{
+    emit_str_array, emit_usize_array, intern_str_array, require_supported_symbol, rust_option_str,
+    rust_str, symbols, verify_count,
+};
+
+const STAGE6_KERNEL_ABIS: &[(&str, &str)] = &[
+    (
+        "jolt.stage6.bytecode_read_raf",
+        "jolt_stage6_bytecode_read_raf",
+    ),
+    ("jolt.stage6.booleanity", "jolt_stage6_booleanity"),
+    (
+        "jolt.stage6.hamming_booleanity",
+        "jolt_stage6_hamming_booleanity",
+    ),
+    ("jolt.stage6.ram_ra_virtual", "jolt_stage6_ram_ra_virtual"),
+    (
+        "jolt.stage6.instruction_ra_virtual",
+        "jolt_stage6_instruction_ra_virtual",
+    ),
+    (
+        "jolt.stage6.inc_claim_reduction",
+        "jolt_stage6_inc_claim_reduction",
+    ),
+    ("jolt.stage6.batched", "jolt_stage6_batched"),
+];
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Stage6CpuProgram {
     pub role: Role,
+    pub(crate) verifier_plan: Option<VerifierStagePlan>,
+    pub(crate) indexed_eval_families: Vec<IndexedEvalFamilyPlan>,
     pub params: Stage6Params,
-    pub steps: Vec<Stage6ProgramStepPlan>,
-    pub transcript_squeezes: Vec<Stage6TranscriptSqueezePlan>,
-    pub transcript_absorb_bytes: Vec<Stage6TranscriptAbsorbBytesPlan>,
-    pub opening_inputs: Vec<Stage6OpeningInputPlan>,
-    pub field_constants: Vec<Stage6FieldConstantPlan>,
-    pub field_exprs: Vec<Stage6FieldExprPlan>,
+    pub steps: Vec<verifier_program_rows::CpuProgramStepPlan>,
+    pub transcript_squeezes: Vec<verifier_program_rows::CpuTranscriptSqueezePlan>,
+    pub transcript_absorb_bytes: Vec<verifier_program_rows::CpuTranscriptAbsorbBytesPlan>,
+    pub opening_inputs: Vec<verifier_program_rows::CpuOpeningInputPlan>,
+    pub field_constants: Vec<verifier_value_rows::CpuFieldConstantPlan>,
+    pub field_exprs: Vec<verifier_value_rows::CpuFieldExprPlan>,
+    pub scalar_exprs: Vec<verifier_value_rows::CpuScalarExprPlan>,
     pub kernels: Vec<Stage6KernelPlan>,
-    pub claims: Vec<Stage6SumcheckClaimPlan>,
-    pub batches: Vec<Stage6SumcheckBatchPlan>,
-    pub drivers: Vec<Stage6SumcheckDriverPlan>,
-    pub instance_results: Vec<Stage6SumcheckInstanceResultPlan>,
-    pub evals: Vec<Stage6SumcheckEvalPlan>,
-    pub point_zeros: Vec<Stage6PointZeroPlan>,
-    pub point_slices: Vec<Stage6PointSlicePlan>,
-    pub point_concats: Vec<Stage6PointConcatPlan>,
-    pub opening_claims: Vec<Stage6OpeningClaimPlan>,
-    pub opening_equalities: Vec<Stage6OpeningClaimEqualityPlan>,
-    pub opening_batches: Vec<Stage6OpeningBatchPlan>,
+    pub claims: Vec<verifier_sumcheck_rows::CpuSumcheckClaimPlan>,
+    pub batches: Vec<verifier_sumcheck_rows::CpuSumcheckBatchPlan>,
+    pub drivers: Vec<verifier_sumcheck_rows::CpuSumcheckDriverPlan>,
+    pub instance_results: Vec<verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan>,
+    pub evals: Vec<verifier_sumcheck_rows::CpuSumcheckEvalPlan>,
+    pub relation_output_values: Vec<Stage6StructuredPolynomialEvalPlan>,
+    pub relation_output_eval_families: Vec<Stage6RelationOutputEvalFamilyPlan>,
+    pub relation_output_product_families: Vec<Stage6RelationOutputProductFamilyPlan>,
+    pub relation_output_function_families: Vec<Stage6RelationOutputFunctionFamilyPlan>,
+    pub relation_outputs: Vec<Stage6RelationOutputPlan>,
+    pub point_zeros: Vec<verifier_point_rows::CpuPointZeroPlan>,
+    pub point_slices: Vec<verifier_point_rows::CpuPointSlicePlan>,
+    pub point_concats: Vec<verifier_point_rows::CpuPointConcatPlan>,
+    pub opening_claims: Vec<verifier_opening_rows::CpuOpeningClaimPlan>,
+    pub opening_equalities: Vec<verifier_opening_rows::CpuOpeningClaimEqualityPlan>,
+    pub opening_batches: Vec<verifier_opening_rows::CpuOpeningBatchPlan>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -53,174 +110,16 @@ pub struct Stage6KernelPlan {
     pub abi: String,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6TranscriptSqueezePlan {
-    pub symbol: String,
-    pub label: String,
-    pub kind: String,
-    pub count: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6TranscriptAbsorbBytesPlan {
-    pub symbol: String,
-    pub label: String,
-    pub payload: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6ProgramStepPlan {
-    pub kind: String,
-    pub symbol: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6OpeningInputPlan {
-    pub symbol: String,
-    pub source_stage: String,
-    pub source_claim: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6FieldConstantPlan {
-    pub symbol: String,
-    pub field: String,
-    pub value: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6FieldExprPlan {
-    pub symbol: String,
-    pub kind: String,
-    pub formula: String,
-    pub operand_names: Vec<String>,
-    pub operands: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6SumcheckClaimPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub domain: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-    pub claim: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub claim_value: String,
-    pub input_openings: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6SumcheckBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub round_schedule: Vec<usize>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6SumcheckDriverPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub batch: String,
-    pub policy: String,
-    pub round_schedule: Vec<usize>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6SumcheckInstanceResultPlan {
-    pub symbol: String,
-    pub source: String,
-    pub claim: String,
-    pub relation: String,
-    pub index: usize,
-    pub point_arity: usize,
-    pub num_rounds: usize,
-    pub round_offset: usize,
-    pub point_order: String,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6SumcheckEvalPlan {
-    pub symbol: String,
-    pub source: String,
-    pub name: String,
-    pub index: usize,
-    pub oracle: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6PointZeroPlan {
-    pub symbol: String,
-    pub field: String,
-    pub arity: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6PointSlicePlan {
-    pub symbol: String,
-    pub source: String,
-    pub offset: usize,
-    pub length: usize,
-    pub input: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6PointConcatPlan {
-    pub symbol: String,
-    pub layout: String,
-    pub arity: usize,
-    pub inputs: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6OpeningClaimPlan {
-    pub symbol: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-    pub point_source: String,
-    pub eval_source: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6OpeningClaimEqualityPlan {
-    pub symbol: String,
-    pub mode: String,
-    pub lhs: String,
-    pub rhs: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage6OpeningBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-}
+verifier_plan::impl_verifier_plan_source_traits!(
+    program = Stage6CpuProgram,
+    absorb = transcript_absorb_bytes,
+    point_zero = verifier_point_rows::CpuPointZeroPlan,
+    indexed_eval_families = indexed_eval_families,
+    relation_output_eval_families = relation_output_eval_families,
+    relation_output_product_families = relation_output_product_families,
+    relation_output_function_families = relation_output_function_families,
+    relation_local_inputs = stage6_bytecode_read_raf,
+);
 
 pub fn stage6_cpu_program(module: &BoltModule<'_, Cpu>) -> Result<Stage6CpuProgram, EmitError> {
     verify_cpu_schema(module)?;
@@ -234,11 +133,17 @@ pub fn emit_stage6_rust(module: &BoltModule<'_, Cpu>) -> Result<RustSourceFile,
 
     Ok(RustSourceFile {
         filename: program.filename().to_owned(),
-        source: program.emit_source(),
+        source: program.emit_source()?,
     })
 }
 
 impl Stage6CpuProgram {
+    pub fn indexed_eval_family_rows(&self) -> impl Iterator<Item = (&str, &[String])> {
+        self.indexed_eval_families
+            .iter()
+            .map(|family| (family.symbol.as_str(), family.evals.as_slice()))
+    }
+
     fn from_module(module: &BoltModule<'_, Cpu>) -> Result<Self, EmitError> {
         let mut params = None;
         let mut steps = Vec::new();
@@ -247,12 +152,19 @@ impl Stage6CpuProgram {
         let mut opening_inputs = Vec::new();
         let mut field_constants = Vec::new();
         let mut field_exprs = Vec::new();
+        let mut scalar_exprs = Vec::new();
         let mut kernels = Vec::new();
         let mut claims = Vec::new();
         let mut batches = Vec::new();
         let mut drivers = Vec::new();
         let mut instance_results = Vec::new();
         let mut evals = Vec::new();
+        let mut indexed_eval_families = Vec::new();
+        let mut relation_output_values = Vec::new();
+        let mut relation_output_eval_families = Vec::new();
+        let mut relation_output_product_families = Vec::new();
+        let mut relation_output_function_families = Vec::new();
+        let mut relation_output_asts = Vec::new();
         let mut point_zeros = Vec::new();
         let mut point_slices = Vec::new();
         let mut point_concats = Vec::new();
@@ -281,272 +193,226 @@ impl Stage6CpuProgram {
                     });
                 }
                 "cpu.transcript_squeeze" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage6ProgramStepPlan {
-                        kind: "transcript_squeeze".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    transcript_squeezes.push(Stage6TranscriptSqueezePlan {
-                        symbol,
-                        label: string_attr(op, "label")?,
-                        kind: string_attr(op, "kind")?,
-                        count: int_attr(op, "count")?,
-                    });
+                    let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "transcript_squeeze",
+                        squeeze.symbol.clone(),
+                    ));
+                    transcript_squeezes.push(squeeze);
                 }
                 "cpu.transcript_absorb_bytes" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage6ProgramStepPlan {
-                        kind: "transcript_absorb_bytes".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    transcript_absorb_bytes.push(Stage6TranscriptAbsorbBytesPlan {
-                        symbol,
-                        label: string_attr(op, "label")?,
-                        payload: string_attr(op, "payload")?,
-                    });
+                    let absorb = verifier_program_rows::CpuTranscriptAbsorbBytesPlan::from_cpu(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "transcript_absorb_bytes",
+                        absorb.symbol.clone(),
+                    ));
+                    transcript_absorb_bytes.push(absorb);
                 }
                 "cpu.opening_input" => {
-                    opening_inputs.push(Stage6OpeningInputPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source_stage: symbol_attr(op, "source_stage")?,
-                        source_claim: symbol_attr(op, "source_claim")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                    });
+                    opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?);
                 }
                 "cpu.field_const" => {
-                    field_constants.push(Stage6FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: int_attr(op, "value")?,
-                    });
+                    field_constants
+                        .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?);
                 }
                 "cpu.field_zero" => {
-                    field_constants.push(Stage6FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 0,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?);
                 }
                 "cpu.field_one" => {
-                    field_constants.push(Stage6FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 1,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?);
                 }
                 "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => {
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage6FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: operation_name(op).replace("cpu.field_", "field."),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?);
                 }
                 "cpu.field_pow" => {
-                    let exponent = int_attr(op, "exponent")?;
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage6FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: format!("field.pow:{exponent}"),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?);
                 }
                 "cpu.sumcheck_claim" => {
-                    claims.push(Stage6SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim(
+                        op,
+                    )?);
                 }
                 "cpu.sumcheck_verify_claim" => {
-                    claims.push(Stage6SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims
+                        .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?);
                 }
                 "cpu.sumcheck_batch" => {
-                    batches.push(Stage6SumcheckBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                    });
+                    batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_driver" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage6ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage6SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_verify" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage6ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage6SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_instance_result" => {
-                    instance_results.push(Stage6SumcheckInstanceResultPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        claim: symbol_attr(op, "claim")?,
-                        relation: symbol_attr(op, "relation")?,
-                        index: int_attr(op, "index")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        round_offset: int_attr(op, "round_offset")?,
-                        point_order: string_attr(op, "point_order")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    instance_results
+                        .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_eval" => {
-                    evals.push(Stage6SumcheckEvalPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        name: symbol_attr(op, "name")?,
-                        index: int_attr(op, "index")?,
-                        oracle: symbol_attr(op, "oracle")?,
+                    evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?);
+                }
+                "cpu.sumcheck_eval_family" => {
+                    indexed_eval_families
+                        .push(verifier_eval_families::parse_indexed_eval_family(op)?);
+                }
+                "cpu.structured_polynomial_eval" => {
+                    relation_output_values.push(
+                        verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?,
+                    );
+                }
+                "cpu.sumcheck_output_eval_family" => {
+                    relation_output_eval_families
+                        .push(parse_output_eval_family_plan("stage6", op)?);
+                }
+                "cpu.sumcheck_output_product_family" => {
+                    relation_output_product_families
+                        .push(parse_output_product_family_plan("stage6", op)?);
+                }
+                "cpu.sumcheck_output_function_family" => {
+                    relation_output_function_families
+                        .push(parse_output_function_family_plan("stage6", op)?);
+                }
+                "cpu.sumcheck_output_claim" => {
+                    relation_output_asts.push(Stage6RelationOutputAst {
+                        relation: symbol_attr(op, "relation")?,
+                        expected_output: operand_symbol(op, 0)?,
+                        polynomial_evals: symbol_array_attr(op, "polynomial_evals")?,
+                        polynomial_eval_operands: operand_symbols(op, 1)?,
                     });
                 }
                 "cpu.point_zero" => {
-                    point_zeros.push(Stage6PointZeroPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        arity: int_attr(op, "arity")?,
-                    });
+                    point_zeros.push(verifier_point_rows::CpuPointZeroPlan::from_cpu(op)?);
                 }
                 "cpu.point_slice" => {
-                    point_slices.push(Stage6PointSlicePlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        offset: int_attr(op, "offset")?,
-                        length: int_attr(op, "length")?,
-                        input: operand_symbol(op, 0)?,
-                    });
+                    point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?);
                 }
                 "cpu.point_concat" => {
-                    point_concats.push(Stage6PointConcatPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        layout: string_attr(op, "layout")?,
-                        arity: int_attr(op, "arity")?,
-                        inputs: operand_symbols(op, 0)?,
-                    });
+                    point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim" => {
-                    opening_claims.push(Stage6OpeningClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                        point_source: operand_symbol(op, 0)?,
-                        eval_source: operand_symbol(op, 1)?,
-                    });
+                    opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim_equal" => {
-                    opening_equalities.push(Stage6OpeningClaimEqualityPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        mode: string_attr(op, "mode")?,
-                        lhs: operand_symbol(op, 0)?,
-                        rhs: operand_symbol(op, 1)?,
-                    });
+                    opening_equalities
+                        .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?);
                 }
                 "cpu.opening_batch" => {
-                    opening_batches.push(Stage6OpeningBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                    });
+                    opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?);
                 }
                 _ => {}
             }
         }
 
-        Ok(Self {
+        let role = module
+            .role()
+            .ok_or_else(|| EmitError::new("missing cpu party role"))?;
+        let is_verifier = role == Role::Verifier;
+        if role == Role::Prover {
+            verifier_relation_outputs::prune_output_only_field_exprs(
+                &mut field_exprs,
+                claims.iter().map(|claim| claim.claim_value.as_str()),
+                relation_output_asts
+                    .iter()
+                    .map(|claim| claim.expected_output.as_str()),
+            );
+        }
+        if role == Role::Verifier {
+            lower_stage6_relation_outputs(
+                &mut field_exprs,
+                &mut relation_output_eval_families,
+                &mut relation_output_product_families,
+                &mut relation_output_function_families,
+                &mut relation_output_asts,
+            )?;
+        }
+        let mut relation_outputs = if role == Role::Verifier {
+            verifier_relation_outputs::resolve_relation_outputs(
+                "stage6",
+                &relation_output_values,
+                &relation_output_eval_families,
+                &relation_output_product_families,
+                &relation_output_function_families,
+                &field_exprs,
+                relation_output_asts,
+            )?
+        } else {
+            Vec::new()
+        };
+        if role == Role::Verifier {
+            let bytecode_output_plan =
+                Stage6BytecodeReadRafEmitPlan::from_eval_families(&indexed_eval_families)?
+                    .relation_output_plan();
+            for expr in bytecode_output_plan.field_exprs {
+                if ScalarExprKind::from_cpu_attr(&expr.formula).is_ok() {
+                    scalar_exprs.push(stage6_scalar_expr(expr));
+                } else {
+                    field_exprs.push(stage6_relation_output_expr(expr));
+                }
+            }
+            relation_outputs.push(bytecode_output_plan.claim);
+            scalar_exprs.extend(
+                relation_output_values
+                    .iter()
+                    .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan)
+                    .map(stage6_scalar_expr),
+            );
+        }
+
+        let mut program = Self {
             params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?,
-            role: module
-                .role()
-                .ok_or_else(|| EmitError::new("missing cpu party role"))?,
+            role,
+            verifier_plan: None,
+            indexed_eval_families,
             steps,
             transcript_squeezes,
             transcript_absorb_bytes,
             opening_inputs,
             field_constants,
             field_exprs,
+            scalar_exprs,
             kernels,
             claims,
             batches,
             drivers,
             instance_results,
             evals,
+            relation_output_values,
+            relation_output_eval_families,
+            relation_output_product_families,
+            relation_output_function_families,
+            relation_outputs,
             point_zeros,
             point_slices,
             point_concats,
             opening_claims,
             opening_equalities,
             opening_batches,
-        })
+        };
+        if is_verifier {
+            program.verifier_plan = Some(program.plan_verifier()?);
+        }
+        Ok(program)
+    }
+
+    fn plan_verifier(&self) -> Result<VerifierStagePlan, EmitError> {
+        verifier_plan::plan_verifier_stage_from_cpu_sources(self)
+    }
+
+    fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> {
+        self.verifier_plan
+            .as_ref()
+            .ok_or_else(|| EmitError::new("missing stage6 verifier plan"))
     }
 
     fn verify_supported_target(&self) -> Result<(), EmitError> {
@@ -555,13 +421,19 @@ impl Stage6CpuProgram {
         require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?;
         self.verify_transcript_steps()?;
         self.verify_field_flow()?;
-        self.verify_claim_batches()?;
         match self.role {
             Role::Prover => {
+                self.verify_claim_batches()?;
                 self.verify_kernel_definitions()?;
                 self.verify_prover_driver_bindings()?;
             }
-            Role::Verifier => self.verify_verifier_driver_bindings()?,
+            Role::Verifier => {
+                self.verifier_plan()?.verify_sumcheck_flow("stage6")?;
+                self.verify_verifier_driver_bindings()?;
+            }
+        }
+        if self.role == Role::Verifier {
+            self.verify_relation_outputs()?;
         }
         self.verify_opening_flow()
     }
@@ -599,23 +471,41 @@ impl Stage6CpuProgram {
         for constant in &self.field_constants {
             require_supported_symbol("field constant field", &constant.field, "bn254_fr")?;
         }
-        let field_values = self.field_value_symbols();
-        for expr in &self.field_exprs {
-            verify_count(
-                "field expr operands",
-                &expr.symbol,
-                expr.operand_names.len(),
-                expr.operands.len(),
-            )?;
-            for operand in &expr.operands {
-                if !field_values.contains(operand) {
-                    return Err(EmitError::new(format!(
-                        "field expr @{} references missing field value @{operand}",
-                        expr.symbol
-                    )));
-                }
-            }
-        }
+        let verifier_plan = if self.role == Role::Verifier {
+            Some(self.verifier_plan()?)
+        } else {
+            None
+        };
+        let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values());
+        let field_values = verifier_scalar_values.as_ref().map_or_else(
+            || self.cpu_field_value_sources(),
+            |values| values.source_set(),
+        );
+        let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values());
+        let verifier_point_values = verifier_plan.map(|plan| plan.point_values());
+        let point_values = verifier_point_values
+            .as_ref()
+            .map(|values| values.source_set());
+        super::plan_tokens::verify_field_expr_flow(
+            super::plan_tokens::FieldExprFlowVerification {
+                cpu_exprs: &self.field_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+            },
+        )?;
+        super::plan_tokens::verify_scalar_expr_flow(
+            super::plan_tokens::ScalarExprFlowVerification {
+                stage: "stage6",
+                cpu_exprs: &self.scalar_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+                field_vector_values: field_vector_values.as_ref(),
+                point_values: point_values.as_ref(),
+                verifier_point_values: verifier_point_values.as_ref(),
+            },
+        )?;
         for claim in &self.claims {
             if !field_values.contains(&claim.claim_value) {
                 return Err(EmitError::new(format!(
@@ -627,19 +517,59 @@ impl Stage6CpuProgram {
         Ok(())
     }
 
-    fn field_value_symbols(&self) -> BTreeSet<String> {
-        let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
-        values.extend(symbols(
+    fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet {
+        let mut values = verifier_values::VerifierScalarSourceSet::default();
+        values.extend(
+            self.opening_inputs.iter().map(|input| &input.symbol),
+            verifier_values::VerifierScalarSourceKind::OpeningInput,
+        );
+        values.extend(
             self.field_constants.iter().map(|constant| &constant.symbol),
-        ));
-        values.extend(symbols(
+            verifier_values::VerifierScalarSourceKind::FieldConstant,
+        );
+        values.extend(
             self.transcript_squeezes
                 .iter()
                 .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar"))
                 .map(|squeeze| &squeeze.symbol),
-        ));
-        values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol)));
-        values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol)));
+            verifier_values::VerifierScalarSourceKind::TranscriptScalar,
+        );
+        values.extend(
+            self.relation_output_eval_families
+                .iter()
+                .map(|family| &family.symbol),
+            verifier_values::VerifierScalarSourceKind::OutputEvalFamily,
+        );
+        values.extend(
+            self.relation_output_product_families
+                .iter()
+                .map(|family| &family.symbol),
+            verifier_values::VerifierScalarSourceKind::OutputProductFamily,
+        );
+        values.extend(
+            self.relation_output_function_families
+                .iter()
+                .map(|family| &family.symbol),
+            verifier_values::VerifierScalarSourceKind::OutputFunctionFamily,
+        );
+        values.extend(
+            self.field_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::FieldExpr,
+        );
+        values.extend(
+            self.scalar_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::ScalarExpr,
+        );
+        values.extend(
+            self.relation_outputs
+                .iter()
+                .flat_map(|claim| claim.local_scalar_symbols()),
+            verifier_values::VerifierScalarSourceKind::RelationOutputLocal,
+        );
+        values.extend(
+            self.evals.iter().map(|eval| &eval.symbol),
+            verifier_values::VerifierScalarSourceKind::SumcheckEval,
+        );
         values
     }
 
@@ -657,21 +587,12 @@ impl Stage6CpuProgram {
                     kernel.symbol, kernel.kind
                 )));
             }
-            let expected_abi = match kernel.relation.as_str() {
-                "jolt.stage6.bytecode_read_raf" => "jolt_stage6_bytecode_read_raf",
-                "jolt.stage6.booleanity" => "jolt_stage6_booleanity",
-                "jolt.stage6.hamming_booleanity" => "jolt_stage6_hamming_booleanity",
-                "jolt.stage6.ram_ra_virtual" => "jolt_stage6_ram_ra_virtual",
-                "jolt.stage6.instruction_ra_virtual" => "jolt_stage6_instruction_ra_virtual",
-                "jolt.stage6.inc_claim_reduction" => "jolt_stage6_inc_claim_reduction",
-                "jolt.stage6.batched" => "jolt_stage6_batched",
-                _ => {
-                    return Err(EmitError::new(format!(
-                        "unsupported stage6 kernel relation @{}",
-                        kernel.relation
-                    )));
-                }
-            };
+            let expected_abi = stage6_kernel_abi(&kernel.relation).ok_or_else(|| {
+                EmitError::new(format!(
+                    "unsupported stage6 kernel relation @{}",
+                    kernel.relation
+                ))
+            })?;
             if kernel.abi != expected_abi {
                 return Err(EmitError::new(format!(
                     "stage6 kernel @{} ABI `{}` does not match relation @{}",
@@ -777,11 +698,6 @@ impl Stage6CpuProgram {
                 "verifier stage6 program must not contain kernels",
             ));
         }
-        let batches: BTreeMap<_, _> = self
-            .batches
-            .iter()
-            .map(|batch| (batch.symbol.as_str(), batch))
-            .collect();
         for claim in &self.claims {
             if claim.kernel.is_some() || claim.relation.is_none() {
                 return Err(EmitError::new(format!(
@@ -797,29 +713,18 @@ impl Stage6CpuProgram {
                     driver.symbol
                 )));
             }
-            let batch = batches.get(driver.batch.as_str()).ok_or_else(|| {
-                EmitError::new(format!(
-                    "sumcheck driver @{} references missing batch @{}",
-                    driver.symbol, driver.batch
-                ))
-            })?;
-            verify_count(
-                "sumcheck driver round_schedule",
-                &driver.symbol,
-                driver.num_rounds,
-                driver.round_schedule.iter().sum(),
-            )?;
-            if driver.round_schedule != batch.round_schedule {
-                return Err(EmitError::new(format!(
-                    "sumcheck driver @{} round_schedule differs from batch @{}",
-                    driver.symbol, batch.symbol
-                )));
-            }
         }
         Ok(())
     }
 
+    fn verify_relation_outputs(&self) -> Result<(), EmitError> {
+        self.verifier_plan()?.verify_relation_outputs("stage6")
+    }
+
     fn verify_opening_flow(&self) -> Result<(), EmitError> {
+        if self.role == Role::Verifier {
+            return self.verifier_plan()?.verify_opening_flow("stage6");
+        }
         let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol));
         point_sources.extend(symbols(
             self.instance_results
@@ -855,7 +760,7 @@ impl Stage6CpuProgram {
                 }
             }
         }
-        let eval_sources = self.field_value_symbols();
+        let eval_sources = self.cpu_field_value_sources();
         let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
         opening_sources.extend(symbols(
             self.opening_claims.iter().map(|claim| &claim.symbol),
@@ -954,7 +859,7 @@ impl Stage6CpuProgram {
         }
     }
 
-    fn emit_source(&self) -> String {
+    fn emit_source(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         source.push_str("#![allow(dead_code)]\n\n");
         match self.role {
@@ -970,10 +875,10 @@ impl Stage6CpuProgram {
             }
         }
         source.push('\n');
-        source.push_str(&self.emit_constants());
+        source.push_str(&self.emit_constants()?);
         source.push('\n');
         source.push_str(self.emit_entrypoint());
-        source
+        Ok(source)
     }
 
     fn emit_prover_imports() -> &'static str {
@@ -987,7 +892,8 @@ impl Stage6CpuProgram {
     }
 
     fn emit_verifier_imports() -> &'static str {
-        "use super::common::{batch_claims, expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, find_batch, find_plan, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};\n\
+        "use bolt_verifier_runtime::find_plan;\n\
+         use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_scalars, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\
          use jolt_field::{Field, Fr};\n\
          use jolt_sumcheck::SumcheckError;\n\
          use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};"
@@ -1207,26 +1113,36 @@ pub struct Stage6CpuProgramPlan {
     }
 
     fn emit_verifier_type_aliases() -> &'static str {
-        r#"pub type Stage6NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage6SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage6ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage6ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage6Proof<F> = super::common::StageProof<F>;
-pub type Stage6OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-
-pub use super::common::{
-    FieldConstantPlan as Stage6FieldConstantPlan, FieldExprPlan as Stage6FieldExprPlan,
+        r#"pub type Stage6NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage6SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage6ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage6ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage6Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage6OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage6CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan<Stage6RelationKind>;
+pub type Stage6SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage6RelationKind>;
+pub type Stage6SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage6RelationKind>;
+pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage6RelationKind>;
+pub type Stage6RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage6RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage6ClaimKind, FieldConstantPlan as Stage6FieldConstantPlan,
+    FieldExprKind as Stage6FieldExprKind,
+    FieldExprPlan as Stage6FieldExprPlan,
+    ScalarExprKind as Stage6ScalarExprKind,
+    ScalarExprPlan as Stage6ScalarExprPlan,
     KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan,
-    PointConcatPlan as Stage6PointConcatPlan, PointSlicePlan as Stage6PointSlicePlan,
-    PointZeroPlan as Stage6PointZeroPlan, ProgramStepPlan as Stage6ProgramStepPlan,
-    StageParams as Stage6Params, StageProgramPlan as Stage6CpuProgramPlan,
+    OpeningEqualityMode as Stage6OpeningEqualityMode, PointExprKind as Stage6PointExprKind,
+    PointExprPlan as Stage6PointExprPlan, ProgramStepKind as Stage6ProgramStepKind,
+    ProgramStepPlan as Stage6ProgramStepPlan,
+    StageParams as Stage6Params,
     SumcheckBatchPlan as Stage6SumcheckBatchPlan,
-    SumcheckClaimPlan as Stage6SumcheckClaimPlan, SumcheckDriverPlan as Stage6SumcheckDriverPlan,
     SumcheckEvalPlan as Stage6SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage6SumcheckInstanceResultPlan,
     TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan,
+    TranscriptSqueezeKind as Stage6TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage6TranscriptSqueezePlan,
 };
 "#
@@ -1237,7 +1153,20 @@ pub use super::common::{
         source.push_str(
             r#"
 pub type DefaultStage6Transcript = Blake2bTranscript<Fr>;
-pub type Stage6VerifierProgramPlan = Stage6CpuProgramPlan;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage6VerifierProgramPlan {
+    pub base: Stage6CpuProgramPlan,
+    pub bytecode_plan: Stage67BytecodeReadRafPlan,
+}
+
+impl core::ops::Deref for Stage6VerifierProgramPlan {
+    type Target = Stage6CpuProgramPlan;
+
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
+}
 
 #[derive(Clone, Debug)]
 pub struct Stage6BytecodeEntry {
@@ -1288,60 +1217,12 @@ pub struct Stage6VerifierData {
 }
 
 const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols {
-    hamming_booleanity_relation: "jolt.stage6.hamming_booleanity",
     hamming_booleanity_instance: "stage6.hamming_booleanity.instance",
-    booleanity_point: "stage6.booleanity.point",
-    stage5_instruction_ra0: "stage6.input.stage5.instruction_read_raf.InstructionRa_0",
-    booleanity_combined_point: "stage6.booleanity.combined_point",
-    booleanity_gamma: "stage6.booleanity.gamma",
-    booleanity_instruction_ra_prefix: "stage6.booleanity.eval.InstructionRa_",
-    booleanity_bytecode_ra_prefix: "stage6.booleanity.eval.BytecodeRa_",
-    booleanity_ram_ra_prefix: "stage6.booleanity.eval.RamRa_",
-    hamming_weight_eval: "stage6.hamming_booleanity.eval.HammingWeight",
-    hamming_lookup_output: "stage6.input.stage1.LookupOutput",
-    ram_ra_virtual_cycle: "stage6.input.stage5.ram_ra_claim_reduction.RamRa",
-    ram_ra_virtual_eval_prefix: "stage6.ram_ra_virtual.eval.RamRa_",
-    instruction_ra_virtual_cycle: "stage6.input.stage5.instruction_read_raf.InstructionRa_0",
-    instruction_ra_virtual_eval_prefix: "stage6.instruction_ra_virtual.eval.InstructionRa_",
-    instruction_ra_virtual_input_prefix: "stage6.input.stage5.instruction_read_raf.InstructionRa_",
-    instruction_ra_virtual_gamma: "stage6.instruction_ra_virtual.gamma",
-    inc_ram_stage2: "stage6.input.stage2.ram_read_write.RamInc",
-    inc_ram_stage4: "stage6.input.stage4.ram_val_check.RamInc",
-    inc_rd_stage4: "stage6.input.stage4.registers_read_write.RdInc",
-    inc_rd_stage5: "stage6.input.stage5.registers_val_evaluation.RdInc",
-    inc_gamma: "stage6.inc_claim_reduction.gamma",
-    inc_ram_eval: "stage6.inc_claim_reduction.eval.RamInc",
-    inc_rd_eval: "stage6.inc_claim_reduction.eval.RdInc",
-};
-
-const STAGE6_BYTECODE_SYMBOLS: Stage67BytecodeSymbols = Stage67BytecodeSymbols {
-    point: "stage6.bytecode_read_raf.point",
-    gamma: "stage6.bytecode_read_raf.gamma",
-    bytecode_ra_eval_prefix: "stage6.bytecode_read_raf.eval.BytecodeRa_",
-    entries: "stage6.bytecode_read_raf.entries",
-    entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index",
-    stage_gammas: [
-        "stage6.bytecode_read_raf.stage1_gamma",
-        "stage6.bytecode_read_raf.stage2_gamma",
-        "stage6.bytecode_read_raf.stage3_gamma",
-        "stage6.bytecode_read_raf.stage4_gamma",
-        "stage6.bytecode_read_raf.stage5_gamma",
-    ],
-    stage_cycle_points: [
-        "stage6.input.stage1.Imm",
-        "stage6.input.stage2.OpFlagJump",
-        "stage6.input.stage3.spartan_shift.UnexpandedPC",
-        "stage6.input.stage4.Rs1Ra",
-        "stage6.input.stage5.registers_val_evaluation.RdWa",
-    ],
-    stage4_register_point: "stage6.input.stage4.Rs1Ra",
-    stage5_register_point: "stage6.input.stage5.registers_val_evaluation.RdWa",
-    entry_rd: "stage6.bytecode.entry.rd",
-    entry_rs1: "stage6.bytecode.entry.rs1",
-    entry_rs2: "stage6.bytecode.entry.rs2",
-    entry_lookup_table: "stage6.bytecode.entry.lookup_table",
 };
-
+"#,
+        );
+        source.push_str(
+            r#"
 #[derive(Debug)]
 pub enum VerifyStage6Error {
     UnexpectedProofCount { expected: usize, got: usize },
@@ -1351,117 +1232,191 @@ pub enum VerifyStage6Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage6RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error);
 "#,
         );
         source
     }
 
-    fn emit_constants(&self) -> String {
-        let mut source = self.emit_shared_constants();
+    fn emit_constants(&self) -> Result<String, EmitError> {
+        let mut source = self.emit_shared_constants()?;
         source.push_str(&self.emit_kernel_constants());
-        source.push_str(&self.emit_sumcheck_claim_constants());
-        source.push_str(&self.emit_sumcheck_batch_constants());
-        source.push_str(&self.emit_sumcheck_driver_constants());
-        source.push_str(&self.emit_tail_constants());
+        source.push_str(&self.emit_sumcheck_claim_constants()?);
+        source.push_str(&self.emit_sumcheck_batch_constants()?);
+        source.push_str(&self.emit_sumcheck_driver_constants()?);
+        source.push_str(&self.emit_tail_constants()?);
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            source.push_str(&self.emit_indexed_eval_family_constants()?);
+            source.push_str(
+                &plan
+                    .relation_local_inputs
+                    .stage6_bytecode_read_raf()?
+                    .emit_runtime_constants(),
+            );
+            source.push_str(&self.emit_verifier_relation_output_constants()?);
+        }
+        let program_field_indent = if self.role == Role::Verifier {
+            "        "
+        } else {
+            "    "
+        };
+        let relation_outputs_field = if self.role == Role::Verifier {
+            format!("{program_field_indent}relation_outputs: STAGE6_RELATION_OUTPUTS,\n")
+        } else {
+            String::new()
+        };
+        let indexed_eval_families_field = if self.role == Role::Verifier {
+            format!("{program_field_indent}indexed_eval_families: STAGE6_INDEXED_EVAL_FAMILIES,\n")
+        } else {
+            String::new()
+        };
+        let scalar_exprs_field = if self.role == Role::Verifier {
+            format!("{program_field_indent}scalar_exprs: STAGE6_SCALAR_EXPRS,\n")
+        } else {
+            String::new()
+        };
+        let point_exprs_field = if self.role == Role::Verifier {
+            format!("{program_field_indent}point_exprs: STAGE6_POINT_EXPRS,\n")
+        } else {
+            format!("{program_field_indent}point_zeros: STAGE6_POINT_ZEROS,\n{program_field_indent}point_slices: STAGE6_POINT_SLICES,\n{program_field_indent}point_concats: STAGE6_POINT_CONCATS,\n")
+        };
+        let program_constructor = if self.role == Role::Verifier {
+            "Stage6VerifierProgramPlan {\n    base: Stage6CpuProgramPlan {"
+        } else {
+            "Stage6CpuProgramPlan {"
+        };
+        let verifier_program_fields = if self.role == Role::Verifier {
+            "    },\n    bytecode_plan: STAGE6_BYTECODE_PLAN,\n"
+        } else {
+            ""
+        };
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE6_PROGRAM: {} = Stage6CpuProgramPlan {{\n\
-                 \x20   role: {},\n\
-                 \x20   params: STAGE6_PARAMS,\n\
-                 \x20   steps: STAGE6_PROGRAM_STEPS,\n\
-                 \x20   transcript_squeezes: STAGE6_TRANSCRIPT_SQUEEZES,\n\
-                 \x20   transcript_absorb_bytes: STAGE6_TRANSCRIPT_ABSORB_BYTES,\n\
-                 \x20   opening_inputs: STAGE6_OPENING_INPUTS,\n\
-                 \x20   field_constants: STAGE6_FIELD_CONSTANTS,\n\
-                 \x20   field_exprs: STAGE6_FIELD_EXPRS,\n\
-                 \x20   kernels: STAGE6_KERNELS,\n\
-                 \x20   claims: STAGE6_SUMCHECK_CLAIMS,\n\
-                 \x20   batches: STAGE6_SUMCHECK_BATCHES,\n\
-                 \x20   drivers: STAGE6_SUMCHECK_DRIVERS,\n\
-                 \x20   instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,\n\
-                 \x20   evals: STAGE6_SUMCHECK_EVALS,\n\
-                 \x20   point_zeros: STAGE6_POINT_ZEROS,\n\
-                 \x20   point_slices: STAGE6_POINT_SLICES,\n\
-                 \x20   point_concats: STAGE6_POINT_CONCATS,\n\
-                 \x20   opening_claims: STAGE6_OPENING_CLAIMS,\n\
-                 \x20   opening_equalities: STAGE6_OPENING_EQUALITIES,\n\
-                 \x20   opening_batches: STAGE6_OPENING_BATCHES,\n\
+                "pub const STAGE6_PROGRAM: {} = {program_constructor}\n\
+                 {program_field_indent}role: {},\n\
+                 {program_field_indent}params: STAGE6_PARAMS,\n\
+                 {program_field_indent}steps: STAGE6_PROGRAM_STEPS,\n\
+                 {program_field_indent}transcript_squeezes: STAGE6_TRANSCRIPT_SQUEEZES,\n\
+                 {program_field_indent}transcript_absorb_bytes: STAGE6_TRANSCRIPT_ABSORB_BYTES,\n\
+                 {program_field_indent}opening_inputs: STAGE6_OPENING_INPUTS,\n\
+                 {program_field_indent}field_constants: STAGE6_FIELD_CONSTANTS,\n\
+                 {program_field_indent}field_exprs: STAGE6_FIELD_EXPRS,\n\
+                 {scalar_exprs_field}\
+                 {program_field_indent}kernels: STAGE6_KERNELS,\n\
+                 {program_field_indent}claims: STAGE6_SUMCHECK_CLAIMS,\n\
+                 {program_field_indent}batches: STAGE6_SUMCHECK_BATCHES,\n\
+                 {program_field_indent}drivers: STAGE6_SUMCHECK_DRIVERS,\n\
+                 {program_field_indent}instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,\n\
+                 {program_field_indent}evals: STAGE6_SUMCHECK_EVALS,\n\
+                 {indexed_eval_families_field}\
+                 {relation_outputs_field}\
+                 {point_exprs_field}\
+                 {program_field_indent}opening_claims: STAGE6_OPENING_CLAIMS,\n\
+                 {program_field_indent}opening_equalities: STAGE6_OPENING_EQUALITIES,\n\
+                 {program_field_indent}opening_batches: STAGE6_OPENING_BATCHES,\n\
+                 {verifier_program_fields}\
                  }};\n",
                 self.program_plan_type(),
                 rust_str(self.role_label())
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_shared_constants(&self) -> String {
+    fn emit_shared_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE6_PARAMS: Stage6Params = Stage6Params {{\n\
-                 \x20   field: {},\n\
-                 \x20   pcs: {},\n\
-                 \x20   transcript: {},\n\
-                 }};\n",
+                "pub const STAGE6_PARAMS: Stage6Params = Stage6Params {{ field: {}, pcs: {}, transcript: {} }};\n",
                 rust_str(&self.params.field),
                 rust_str(&self.params.pcs),
                 rust_str(&self.params.transcript)
             ),
         );
-        source.push_str(&self.emit_program_step_constants());
-        source.push_str(&self.emit_transcript_squeeze_constants());
-        source.push_str(&self.emit_transcript_absorb_bytes_constants());
-        source.push_str(&self.emit_opening_input_constants());
+        source.push_str(&self.emit_program_step_constants()?);
+        source.push_str(&self.emit_transcript_squeeze_constants()?);
+        source.push_str(&self.emit_transcript_absorb_bytes_constants()?);
+        source.push_str(&self.emit_opening_input_constants()?);
         source.push_str(&self.emit_field_constant_constants());
-        source.push_str(&self.emit_field_expr_constants());
-        source
+        source.push_str(&self.emit_field_expr_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_scalar_expr_constants()?);
+        }
+        Ok(source)
     }
 
-    fn emit_program_step_constants(&self) -> String {
+    fn emit_program_step_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_program_step_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.steps,
+            ));
+        }
         let steps = self
             .steps
             .iter()
             .map(|step| {
-                format!(
+                Ok(format!(
                     "    Stage6ProgramStepPlan {{ kind: {}, symbol: {} }},",
-                    rust_str(&step.kind),
+                    super::plan_tokens::role_program_step_kind_expr(
+                        "Stage6", &self.role, &step.kind
+                    )?,
                     rust_str(&step.symbol),
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE6_PROGRAM_STEPS: &[Stage6ProgramStepPlan] = &[\n{steps}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE6_PROGRAM_STEPS: &[Stage6ProgramStepPlan] = &[\n{steps}\n];\n\n"
+        ))
     }
 
-    fn emit_transcript_squeeze_constants(&self) -> String {
+    fn emit_transcript_squeeze_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_transcript_squeeze_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.transcript_squeezes,
+            ));
+        }
         let squeezes = self
             .transcript_squeezes
             .iter()
             .map(|squeeze| {
-                format!(
+                Ok(format!(
                     "    Stage6TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},",
                     rust_str(&squeeze.symbol),
                     rust_str(&squeeze.label),
-                    rust_str(&squeeze.kind),
+                    super::plan_tokens::role_transcript_squeeze_kind_expr("Stage6", &self.role, &squeeze.kind)?,
                     squeeze.count,
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE6_TRANSCRIPT_SQUEEZES: &[Stage6TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_transcript_absorb_bytes_constants(&self) -> String {
+    fn emit_transcript_absorb_bytes_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_transcript_absorb_bytes_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.transcript_absorb_bytes,
+            ));
+        }
         let absorbs = self
             .transcript_absorb_bytes
             .iter()
@@ -1475,17 +1430,25 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE6_TRANSCRIPT_ABSORB_BYTES: &[Stage6TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_opening_input_constants(&self) -> String {
+    fn emit_opening_input_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_input_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.opening_inputs,
+            ));
+        }
         let inputs = self
             .opening_inputs
             .iter()
             .map(|input| {
-                format!(
+                Ok(format!(
                     "    Stage6OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},",
                     rust_str(&input.symbol),
                     rust_str(&input.source_stage),
@@ -1493,12 +1456,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
                     rust_str(&input.oracle),
                     rust_str(&input.domain),
                     input.point_arity,
-                    rust_str(&input.claim_kind)
-                )
+                    super::plan_tokens::role_claim_kind_expr("Stage6", &self.role, &input.claim_kind)?
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[\n{inputs}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[\n{inputs}\n];\n\n"
+        ))
     }
 
     fn emit_field_constant_constants(&self) -> String {
@@ -1520,31 +1485,16 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
         )
     }
 
-    fn emit_field_expr_constants(&self) -> String {
+    fn emit_field_expr_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let rows = self
-                .field_exprs
-                .chunks(8)
-                .map(|chunk| {
-                    let exprs = chunk
-                        .iter()
-                        .map(|expr| {
-                            format!(
-                                "stage6_field_expr!({}, {}, {})",
-                                rust_str(&expr.symbol),
-                                rust_str(&expr.formula),
-                                rust_str(&expr.operands.join("|"))
-                            )
-                        })
-                        .collect::<Vec<_>>()
-                        .join(", ");
-                    format!("    {exprs},")
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "macro_rules! stage6_field_expr {{\n    ($symbol:literal, $formula:literal, $operands:literal) => {{\n        Stage6FieldExprPlan {{ symbol: $symbol, kind: \"op\", formula: $formula, operands: $operands }}\n    }};\n}}\n\n#[rustfmt::skip]\npub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{rows}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_field_expr_constants_chunked(
+                "Stage6",
+                "STAGE6",
+                "stage6_field_expr",
+                &plan.field_exprs,
+                8,
+            ));
         }
 
         let mut source = String::new();
@@ -1586,7 +1536,18 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
                 "pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{exprs}\n];\n"
             ),
         );
-        source
+        Ok(source)
+    }
+
+    fn emit_scalar_expr_constants(&self) -> Result<String, EmitError> {
+        let plan = self.verifier_plan()?;
+        Ok(verifier_plan::emit_scalar_expr_constants_chunked(
+            "Stage6",
+            "STAGE6",
+            "stage6_scalar_expr",
+            &plan.scalar_exprs,
+            16,
+        ))
     }
 
     fn emit_kernel_constants(&self) -> String {
@@ -1608,31 +1569,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
         format!("pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[\n{kernels}\n];\n\n")
     }
 
-    fn emit_sumcheck_claim_constants(&self) -> String {
+    fn emit_sumcheck_claim_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let claims = self
-                .claims
-                .iter()
-                .map(|claim| {
-                    format!(
-                        "    Stage6SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},",
-                        rust_str(&claim.symbol),
-                        rust_str(&claim.stage),
-                        rust_str(&claim.domain),
-                        claim.num_rounds,
-                        claim.degree,
-                        rust_str(&claim.claim),
-                        rust_option_str(claim.kernel.as_deref()),
-                        rust_option_str(claim.relation.as_deref()),
-                        rust_str(&claim.claim_value),
-                        rust_str(&claim.input_openings.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[\n{claims}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_claim_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.claims,
+            ));
         }
 
         let mut source = String::new();
@@ -1647,7 +1591,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
             .iter()
             .enumerate()
             .map(|(index, claim)| {
-                format!(
+                Ok(format!(
                     "    Stage6SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: STAGE6_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.stage),
@@ -1656,11 +1600,15 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
                     claim.degree,
                     rust_str(&claim.claim),
                     rust_option_str(claim.kernel.as_deref()),
-                    rust_option_str(claim.relation.as_deref()),
+                    super::plan_tokens::role_optional_relation_kind_expr(
+                        "Stage6",
+                        &self.role,
+                        claim.relation.as_deref()
+                    )?,
                     rust_str(&claim.claim_value)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
         push_format(
             &mut source,
@@ -1668,45 +1616,17 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
                 "pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[\n{claims}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_sumcheck_batch_constants(&self) -> String {
+    fn emit_sumcheck_batch_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let mut source = String::new();
-            for (index, batch) in self.batches.iter().enumerate() {
-                source.push_str(&emit_usize_array(
-                    &format!("STAGE6_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"),
-                    &batch.round_schedule,
-                ));
-            }
-            let batches = self
-                .batches
-                .iter()
-                .enumerate()
-                .map(|(index, batch)| {
-                    format!(
-                        "    Stage6SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE6_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
-                        rust_str(&batch.symbol),
-                        rust_str(&batch.stage),
-                        rust_str(&batch.proof_slot),
-                        rust_str(&batch.policy),
-                        batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|")),
-                        rust_str(&batch.claim_label),
-                        rust_str(&batch.round_label)
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            push_format(
-                &mut source,
-                format_args!(
-                    "pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[\n{batches}\n];\n"
-                ),
-            );
-            return source;
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_batch_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.batches,
+            ));
         }
 
         let mut source = String::new();
@@ -1748,10 +1668,18 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
                 "pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[\n{batches}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_sumcheck_driver_constants(&self) -> String {
+    fn emit_sumcheck_driver_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_driver_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.drivers,
+            ));
+        }
         let mut source = String::new();
         for (index, driver) in self.drivers.iter().enumerate() {
             source.push_str(&emit_usize_array(
@@ -1764,22 +1692,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
             .iter()
             .enumerate()
             .map(|(index, driver)| {
-                format!(
+                Ok(format!(
                     "    Stage6SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: {}, relation: {}, batch: {}, policy: {}, round_schedule: STAGE6_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},",
                     rust_str(&driver.symbol),
                     rust_str(&driver.stage),
                     rust_str(&driver.proof_slot),
                     rust_option_str(driver.kernel.as_deref()),
-                    rust_option_str(driver.relation.as_deref()),
+                    super::plan_tokens::role_optional_relation_kind_expr(
+                        "Stage6",
+                        &self.role,
+                        driver.relation.as_deref()
+                    )?,
                     rust_str(&driver.batch),
                     rust_str(&driver.policy),
                     rust_str(&driver.claim_label),
                     rust_str(&driver.round_label),
                     driver.num_rounds,
                     driver.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
         push_format(
             &mut source,
@@ -1787,46 +1719,59 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
                 "pub const STAGE6_SUMCHECK_DRIVERS: &[Stage6SumcheckDriverPlan] = &[\n{drivers}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_tail_constants(&self) -> String {
+    fn emit_tail_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
-        source.push_str(&self.emit_sumcheck_instance_result_constants());
+        source.push_str(&self.emit_sumcheck_instance_result_constants()?);
         source.push_str(&self.emit_sumcheck_eval_constants());
-        source.push_str(&self.emit_point_zero_constants());
-        source.push_str(&self.emit_point_slice_constants());
-        source.push_str(&self.emit_point_concat_constants());
-        source.push_str(&self.emit_opening_claim_constants());
-        source.push_str(&self.emit_opening_claim_equality_constants());
-        source.push_str(&self.emit_opening_batch_constants());
-        source
+        source.push_str(&self.emit_point_constants()?);
+        source.push_str(&self.emit_opening_claim_constants()?);
+        source.push_str(&self.emit_opening_claim_equality_constants()?);
+        source.push_str(&self.emit_opening_batch_constants()?);
+        Ok(source)
     }
 
-    fn emit_sumcheck_instance_result_constants(&self) -> String {
+    fn emit_sumcheck_instance_result_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_instance_result_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.instance_results,
+            ));
+        }
         let instances = self
             .instance_results
             .iter()
             .map(|instance| {
-                format!(
+                Ok(format!(
                     "    Stage6SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},",
                     rust_str(&instance.symbol),
                     rust_str(&instance.source),
                     rust_str(&instance.claim),
-                    rust_str(&instance.relation),
+                    super::plan_tokens::role_relation_kind_expr(
+                        "Stage6",
+                        &self.role,
+                        &instance.relation
+                    )?,
                     instance.index,
                     instance.point_arity,
                     instance.num_rounds,
                     instance.round_offset,
-                    rust_str(&instance.point_order),
+                    super::plan_tokens::role_sumcheck_point_order_expr(
+                        &self.role,
+                        &instance.point_order
+                    )?,
                     instance.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE6_SUMCHECK_INSTANCE_RESULTS: &[Stage6SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n"
-        )
+        ))
     }
 
     fn emit_sumcheck_eval_constants(&self) -> String {
@@ -1838,7 +1783,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
                     .iter()
                     .map(|eval| {
                         format!(
-                            "stage6_sumcheck_eval!({}, {}, {}, {}, {})",
+                            "stage6_sumcheck_eval({}, {}, {}, {}, {})",
                             rust_str(&eval.symbol),
                             rust_str(&eval.source),
                             rust_str(&eval.name),
@@ -1853,11 +1798,38 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
             .collect::<Vec<_>>()
             .join("\n");
         format!(
-            "macro_rules! stage6_sumcheck_eval {{\n    ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => {{\n        Stage6SumcheckEvalPlan {{ symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle }}\n    }};\n}}\n\n#[rustfmt::skip]\npub const STAGE6_SUMCHECK_EVALS: &[Stage6SumcheckEvalPlan] = &[\n{rows}\n];\n\n"
+            "const fn stage6_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage6SumcheckEvalPlan {{\n    Stage6SumcheckEvalPlan {{ symbol, source, name, index, oracle }}\n}}\n\n#[rustfmt::skip]\npub const STAGE6_SUMCHECK_EVALS: &[Stage6SumcheckEvalPlan] = &[\n{rows}\n];\n\n"
+        )
+    }
+
+    fn emit_indexed_eval_family_constants(&self) -> Result<String, EmitError> {
+        Ok(verifier_eval_families::emit_named_runtime_slice_constant(
+            &self.verifier_plan()?.indexed_eval_families,
+            "pub ",
+            "STAGE6_INDEXED_EVAL_FAMILY",
+            "STAGE6_INDEXED_EVAL_FAMILIES",
+        ))
+    }
+
+    fn emit_verifier_relation_output_constants(&self) -> Result<String, EmitError> {
+        super::relation_outputs::emit_verifier_relation_output_constants(
+            "Stage6",
+            &self.role,
+            &self.relation_outputs,
         )
     }
 
-    fn emit_point_zero_constants(&self) -> String {
+    fn emit_point_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_point_expr_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.point_exprs,
+            ));
+        }
+
+        let mut source = String::new();
         let zeros = self
             .point_zeros
             .iter()
@@ -1871,10 +1843,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!("pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[\n{zeros}\n];\n\n")
-    }
-
-    fn emit_point_slice_constants(&self) -> String {
+        push_format(
+            &mut source,
+            format_args!(
+                "pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[\n{zeros}\n];\n\n"
+            ),
+        );
         let slices = self
             .point_slices
             .iter()
@@ -1890,31 +1864,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!("pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[\n{slices}\n];\n\n")
-    }
-
-    fn emit_point_concat_constants(&self) -> String {
-        if self.role == Role::Verifier {
-            let concats = self
-                .point_concats
-                .iter()
-                .map(|concat| {
-                    format!(
-                        "    Stage6PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},",
-                        rust_str(&concat.symbol),
-                        rust_str(&concat.layout),
-                        concat.arity,
-                        rust_str(&concat.inputs.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[\n{concats}\n];\n"
-            );
-        }
-
-        let mut source = String::new();
+        push_format(
+            &mut source,
+            format_args!(
+                "pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[\n{slices}\n];\n\n"
+            ),
+        );
         for (index, concat) in self.point_concats.iter().enumerate() {
             source.push_str(&emit_str_array(
                 &format!("STAGE6_POINT_CONCAT_{index}_INPUTS"),
@@ -1941,72 +1896,76 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
                 "pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[\n{concats}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_opening_claim_constants(&self) -> String {
+    fn emit_opening_claim_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.opening_claims,
+            ));
+        }
         let claims = self
             .opening_claims
             .iter()
             .map(|claim| {
-                format!(
+                Ok(format!(
                     "    Stage6OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.oracle),
                     rust_str(&claim.domain),
                     claim.point_arity,
-                    rust_str(&claim.claim_kind),
+                    super::plan_tokens::role_claim_kind_expr("Stage6", &self.role, &claim.claim_kind)?,
                     rust_str(&claim.point_source),
                     rust_str(&claim.eval_source)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[\n{claims}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[\n{claims}\n];\n\n"
+        ))
     }
 
-    fn emit_opening_claim_equality_constants(&self) -> String {
+    fn emit_opening_claim_equality_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_equality_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.opening_equalities,
+            ));
+        }
         let equalities = self
             .opening_equalities
             .iter()
             .map(|equality| {
-                format!(
+                Ok(format!(
                     "    Stage6OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},",
                     rust_str(&equality.symbol),
-                    rust_str(&equality.mode),
+                    super::plan_tokens::role_opening_equality_mode_expr("Stage6", &self.role, &equality.mode)?,
                     rust_str(&equality.lhs),
                     rust_str(&equality.rhs)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE6_OPENING_EQUALITIES: &[Stage6OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_opening_batch_constants(&self) -> String {
+    fn emit_opening_batch_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let batches = self
-                .opening_batches
-                .iter()
-                .map(|batch| {
-                    format!(
-                        "    Stage6OpeningBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {} }},",
-                        rust_str(&batch.symbol),
-                        rust_str(&batch.stage),
-                        rust_str(&batch.proof_slot),
-                        rust_str(&batch.policy),
-                        batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[\n{batches}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_batch_constants(
+                "Stage6",
+                "STAGE6",
+                &plan.opening_batches,
+            ));
         }
 
         let mut source = String::new();
@@ -2042,7 +2001,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
                 "pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[\n{batches}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
     fn emit_entrypoint(&self) -> &'static str {
@@ -2101,20 +2060,19 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
-    store.seed_point_zeros(program.point_zeros);
     let mut artifacts = Stage6ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage6ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage6Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage6_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "transcript_absorb_bytes" => {
+            Stage6ProgramStepKind::TranscriptAbsorbBytes => {
                 let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or(
                     VerifyStage6Error::MissingValue {
                         symbol: step.symbol,
@@ -2122,7 +2080,7 @@ where
                 )?;
                 absorb_stage6_bytes(absorb, transcript);
             }
-            "sumcheck_driver" => {
+            Stage6ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage6Error::MissingProof {
                         driver: step.symbol,
@@ -2137,12 +2095,6 @@ where
                     &mut artifacts,
                 )?;
             }
-            _ => {
-                return Err(VerifyStage6Error::InvalidProof {
-                    driver: step.symbol,
-                    reason: "unsupported stage6 program step",
-                });
-            }
         }
     }
     artifacts
@@ -2158,7 +2110,7 @@ pub fn stage6_verifier_program() -> &'static Stage6VerifierProgramPlan {
 fn verify_stage6_squeeze<T>(
     program: &'static Stage6VerifierProgramPlan,
     squeeze: &'static Stage6TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage6ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage6Error>
@@ -2178,7 +2130,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage6Error::from)?;
     artifacts.challenge_vectors.push(Stage6ChallengeVector {
         symbol: squeeze.symbol,
@@ -2203,7 +2155,7 @@ fn verify_stage6_driver<T>(
     driver: &'static Stage6SumcheckDriverPlan,
     proof: &Stage6Proof<Fr>,
     verifier_data: Option<&Stage6VerifierData>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage6ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage6Error>
@@ -2216,12 +2168,17 @@ where
         .ok_or(VerifyStage6Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage6Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage6.batched" => {
+        Stage6RelationKind::Stage6Batched => {
             verify_batched_stage6(program, driver, proof, verifier_data, store, transcript)?
         }
-        _ => return Err(VerifyStage6Error::UnsupportedRelation { relation }),
+        relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -2232,32 +2189,49 @@ fn verify_batched_stage6<T>(
     driver: &'static Stage6SumcheckDriverPlan,
     proof: &Stage6SumcheckOutput<Fr>,
     verifier_data: Option<&Stage6VerifierData>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage6SumcheckOutput<Fr>, VerifyStage6Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage6Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(
-                program,
+            bolt_verifier_runtime::evaluate_relation_output_batch(
                 driver,
-                verifier_data,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                program.indexed_eval_families,
                 store,
                 evals,
                 point,
                 batching_coeffs,
+                |instance, relation_output, local_point| {
+                    stage6_relation_output_inputs(program, verifier_data, store, instance, relation_output, local_point)
+                },
             )
         },
         |store, verified| observe_stage6_sumcheck_output(program, store, verified),
@@ -2267,7 +2241,7 @@ where
 
 fn observe_stage6_sumcheck_output<F: Field>(
     program: &'static Stage6VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage6SumcheckOutput<F>,
 ) -> Result<(), VerifyStage6Error> {
     store.observe_sumcheck_output(
@@ -2276,16 +2250,16 @@ fn observe_stage6_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?,
-                "stage6_booleanity" => {}
-                "instruction_read_raf" => point = normalize_instruction_read_raf_point(&point, "stage6.instruction_read_raf.point")?,
-                _ => {
-                    return Err(VerifyStage6Error::InvalidProof {
-                        driver: output.driver,
-                        reason: "unsupported point order",
-                    });
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
+                    if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf {
+                        return Err(VerifyStage6Error::InvalidProof {
+                            driver: output.driver,
+                            reason: "unsupported relation-local point order",
+                        });
+                    }
+                    point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?;
                 }
             }
             Ok(point)
@@ -2297,9 +2271,9 @@ fn observe_stage6_sumcheck_output<F: Field>(
         },
         |symbol| VerifyStage6Error::MissingValue { symbol },
     )?;
+    store.evaluate_named_eval_families(program.indexed_eval_families)?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage6Error::InvalidInputLength {
             input,
             expected,
@@ -2307,7 +2281,7 @@ fn observe_stage6_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage6Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -2316,127 +2290,38 @@ fn observe_stage6_sumcheck_output<F: Field>(
     )
 }
 
-fn expected_batched_output_claim(
+fn stage6_relation_output_inputs<'a>(
     program: &'static Stage6VerifierProgramPlan,
-    driver: &'static Stage6SumcheckDriverPlan,
     verifier_data: Option<&Stage6VerifierData>,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage6Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage6Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let relation = claim.relation.unwrap_or("<missing>");
-        let value = match relation {
-            "jolt.stage6.bytecode_read_raf" => {
-                let data = verifier_data
-                    .and_then(|data| data.bytecode_read_raf.as_ref())
-                    .ok_or(VerifyStage6Error::MissingValue {
-                        symbol: "stage6.bytecode_read_raf.data",
-                })?;
-                expected_bytecode_read_raf(program, data, store, evals, local_point)?
-            }
-            "jolt.stage6.booleanity" => {
-                expected_booleanity(program, store, evals, local_point)?
-            }
-            "jolt.stage6.hamming_booleanity" => {
-                expected_hamming_booleanity(store, evals, local_point)?
-            }
-            "jolt.stage6.ram_ra_virtual" => {
-                expected_ram_ra_virtual(store, evals, local_point)?
-            }
-            "jolt.stage6.instruction_ra_virtual" => {
-                expected_instruction_ra_virtual(program, store, evals, local_point)?
-            }
-            "jolt.stage6.inc_claim_reduction" => {
-                expected_inc_claim_reduction(store, evals, local_point)?
-            }
-            _ => return Err(VerifyStage6Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
+    store: &bolt_verifier_runtime::ValueStore<Fr>,
+    instance: &Stage6SumcheckInstanceResultPlan,
+    relation_output: &Stage6RelationOutputPlan,
+    local_point: &'a [Fr],
+) -> Result<bolt_verifier_runtime::RelationOutputInputs<'a, Fr>, VerifyStage6Error> {
+    if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf {
+        return Ok(bolt_verifier_runtime::RelationOutputInputs::empty());
     }
-    Ok(expected)
-}
 
-fn expected_bytecode_read_raf(
-    program: &'static Stage6VerifierProgramPlan,
-    data: &Stage6BytecodeReadRafData,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    let log_t = stage6_trace_rounds(program)?;
-    Ok(expected_stage67_bytecode_read_raf(
-        &data.entries,
-        data.entry_bytecode_index,
-        data.num_lookup_tables,
-        store,
-        evals,
-        local_point,
-        log_t,
-        &STAGE6_BYTECODE_SYMBOLS,
-    )?)
-}
-
-fn expected_booleanity(
-    program: &'static Stage6VerifierProgramPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    let log_t = stage6_trace_rounds(program)?;
-    Ok(expected_stage67_booleanity(store, evals, local_point, log_t, &STAGE6_RELATION_SYMBOLS)?)
-}
-
-fn expected_hamming_booleanity(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    Ok(expected_stage67_hamming_booleanity(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?)
-}
-
-fn expected_ram_ra_virtual(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    Ok(expected_stage67_ram_ra_virtual(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?)
-}
-
-fn expected_instruction_ra_virtual(
-    program: &'static Stage6VerifierProgramPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    Ok(expected_stage67_instruction_ra_virtual(program.opening_inputs, store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?)
-}
-
-fn expected_inc_claim_reduction(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    Ok(expected_stage67_inc_claim_reduction(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?)
+    let data = verifier_data
+        .and_then(|data| data.bytecode_read_raf.as_ref())
+        .ok_or(VerifyStage6Error::MissingValue {
+            symbol: "stage6.bytecode_read_raf.data",
+    })?;
+    Ok(bolt_verifier_runtime::RelationOutputInputs {
+        scalars: bolt_verifier_runtime::select_named_scalars(
+            relation_output.local_scalars,
+            evaluate_stage67_bytecode_read_raf_output_scalars(
+                &program.bytecode_plan,
+                &data.entries,
+                data.entry_bytecode_index,
+                data.num_lookup_tables,
+                store,
+                local_point,
+                stage6_trace_rounds(program)?,
+            )?,
+        )?,
+        points: Vec::new(),
+    })
 }
 
 fn stage6_trace_rounds(
@@ -2464,196 +2349,148 @@ fn stage6_trace_rounds(
     }
 }
 
-fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result<(), EmitError> {
-    if actual == expected {
-        Ok(())
-    } else {
-        Err(EmitError::new(format!(
-            "unsupported {kind} @{actual}; expected @{expected}"
-        )))
-    }
+fn lower_stage6_relation_outputs(
+    field_exprs: &mut Vec<verifier_value_rows::CpuFieldExprPlan>,
+    relation_output_eval_families: &mut Vec<Stage6RelationOutputEvalFamilyPlan>,
+    relation_output_product_families: &mut Vec<Stage6RelationOutputProductFamilyPlan>,
+    relation_output_function_families: &mut Vec<Stage6RelationOutputFunctionFamilyPlan>,
+    relation_output_asts: &mut [Stage6RelationOutputAst],
+) -> Result<(), EmitError> {
+    field_exprs.extend(
+        verifier_relation_outputs::lower_boolean_zero_function_family_output(
+            "stage6",
+            "jolt.stage6.booleanity",
+            relation_output_function_families,
+            relation_output_asts,
+        )?
+        .into_iter()
+        .map(stage6_relation_output_expr),
+    );
+    field_exprs.extend(
+        verifier_relation_outputs::lower_boolean_zero_function_family_output(
+            "stage6",
+            "jolt.stage6.hamming_booleanity",
+            relation_output_function_families,
+            relation_output_asts,
+        )?
+        .into_iter()
+        .map(stage6_relation_output_expr),
+    );
+    field_exprs.extend(
+        verifier_relation_outputs::lower_eval_family_output(
+            "stage6",
+            "jolt.stage6.inc_claim_reduction",
+            relation_output_eval_families,
+            relation_output_asts,
+        )?
+        .into_iter()
+        .map(stage6_relation_output_expr),
+    );
+    field_exprs.extend(
+        verifier_relation_outputs::lower_product_family_output(
+            "stage6",
+            "jolt.stage6.ram_ra_virtual",
+            relation_output_product_families,
+            relation_output_asts,
+        )?
+        .into_iter()
+        .map(stage6_relation_output_expr),
+    );
+    field_exprs.extend(
+        verifier_relation_outputs::lower_product_family_output(
+            "stage6",
+            "jolt.stage6.instruction_ra_virtual",
+            relation_output_product_families,
+            relation_output_asts,
+        )?
+        .into_iter()
+        .map(stage6_relation_output_expr),
+    );
+    Ok(())
 }
 
-fn emit_str_array(name: &str, values: &[String]) -> String {
-    if values.is_empty() {
-        return format!("pub const {name}: &[&str] = &[];\n\n");
-    }
-    if let [value] = values {
-        return format!("pub const {name}: &[&str] = &[{}];\n\n", rust_str(value));
-    }
-    let entries = values
-        .iter()
-        .map(|value| format!("    {},", rust_str(value)))
-        .collect::<Vec<_>>()
-        .join("\n");
-    format!("pub const {name}: &[&str] = &[\n{entries}\n];\n\n")
+fn stage6_relation_output_expr(
+    expr: Stage6RelationOutputFieldExprPlan,
+) -> verifier_value_rows::CpuFieldExprPlan {
+    verifier_value_rows::CpuFieldExprPlan::op(expr.symbol, expr.formula, expr.operands)
 }
 
-fn emit_usize_array(name: &str, values: &[usize]) -> String {
-    let entries = values
-        .iter()
-        .map(|value| format!("    {value},"))
-        .collect::<Vec<_>>()
-        .join("\n");
-    format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n")
+fn stage6_scalar_expr(
+    expr: Stage6RelationOutputFieldExprPlan,
+) -> verifier_value_rows::CpuScalarExprPlan {
+    verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands)
 }
 
-fn intern_str_array(
-    source: &mut String,
-    arrays: &mut Vec<(Vec<String>, String)>,
-    name_prefix: &str,
-    values: &[String],
-) -> String {
-    if let Some((_, name)) = arrays
+fn stage6_kernel_abi(relation: &str) -> Option<&'static str> {
+    STAGE6_KERNEL_ABIS
         .iter()
-        .find(|(existing, _)| existing.as_slice() == values)
-    {
-        return name.clone();
-    }
-    let name = format!("{name_prefix}_{}", arrays.len());
-    source.push_str(&emit_str_array(&name, values));
-    arrays.push((values.to_vec(), name.clone()));
-    name
+        .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi))
 }
 
-fn rust_str(value: &str) -> String {
-    format!("{value:?}")
-}
+#[cfg(test)]
+mod tests {
+    use crate::emit::rust::EmitError;
+    use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{
+        Stage6BytecodeReadRafEmitPlan, STAGE6_BYTECODE_RA_EVAL_FAMILY,
+    };
+    use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan;
 
-fn rust_option_str(value: Option<&str>) -> String {
-    value.map_or_else(
-        || "None".to_owned(),
-        |value| format!("Some({})", rust_str(value)),
-    )
-}
+    use super::{stage6_kernel_abi, STAGE6_KERNEL_ABIS};
 
-fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Result<(), EmitError> {
-    if expected == actual {
-        Ok(())
-    } else {
-        Err(EmitError::new(format!(
-            "{kind} @{symbol} count mismatch: expected {expected}, got {actual}"
-        )))
+    #[test]
+    fn stage6_kernel_abi_contracts_cover_supported_relations() {
+        assert_eq!(STAGE6_KERNEL_ABIS.len(), 7);
+        assert_eq!(
+            stage6_kernel_abi("jolt.stage6.bytecode_read_raf"),
+            Some("jolt_stage6_bytecode_read_raf")
+        );
+        assert_eq!(
+            stage6_kernel_abi("jolt.stage6.batched"),
+            Some("jolt_stage6_batched")
+        );
+        assert_eq!(stage6_kernel_abi("jolt.stage7.batched"), None);
     }
-}
-
-fn symbols<'a>(values: impl Iterator<Item = &'a String>) -> BTreeSet<String> {
-    values.cloned().collect()
-}
-
-fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(string_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "string"))
-}
-
-fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(symbol_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "symbol"))
-}
-
-fn symbol_array_attr(
-    operation: OperationRef<'_, '_>,
-    attr: &str,
-) -> Result<Vec<String>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "symbol array"))?;
-    parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array"))
-}
 
-fn parse_symbol_array(attribute: &str) -> Option<Vec<String>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
+    #[test]
+    fn stage6_bytecode_read_raf_eval_family_uses_explicit_row_order() -> Result<(), EmitError> {
+        let families = [IndexedEvalFamilyPlan {
+            symbol: STAGE6_BYTECODE_RA_EVAL_FAMILY.to_owned(),
+            evals: vec![
+                "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(),
+                "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(),
+                "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(),
+            ],
+        }];
+        let plan = Stage6BytecodeReadRafEmitPlan::from_eval_families(&families)?;
+        assert_eq!(
+            plan.bytecode_ra_evals_ref,
+            "STAGE6_INDEXED_EVAL_FAMILIES[0]"
+        );
+        assert_eq!(
+            plan.bytecode_ra_evals.evals,
+            vec![
+                "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(),
+                "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(),
+                "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(),
+            ]
+        );
+        Ok(())
     }
-    inner
-        .split(',')
-        .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned))
-        .collect()
-}
-
-fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<usize, EmitError> {
-    operation
-        .attribute(attr)
-        .map(parse_integer_attr)
-        .ok()
-        .flatten()
-        .ok_or_else(|| attr_error(operation, attr, "integer"))
-}
 
-fn parse_integer_attr(attribute: Attribute<'_>) -> Option<usize> {
-    attribute
-        .to_string()
-        .split_whitespace()
-        .next()
-        .and_then(|value| value.parse().ok())
-}
-
-fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<Vec<usize>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "integer array"))?;
-    parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array"))
-}
-
-fn parse_int_array(attribute: &str) -> Option<Vec<usize>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
+    #[test]
+    fn stage6_bytecode_read_raf_eval_family_requires_explicit_plan_row() {
+        let families = [IndexedEvalFamilyPlan {
+            symbol: "stage6.other.eval.BytecodeRa".to_owned(),
+            evals: vec!["stage6.other.eval.BytecodeRa_0".to_owned()],
+        }];
+
+        let error = Stage6BytecodeReadRafEmitPlan::from_eval_families(&families)
+            .err()
+            .map(|error| error.to_string())
+            .unwrap_or_default();
+
+        assert!(error.contains(&format!(
+            "missing eval family `{STAGE6_BYTECODE_RA_EVAL_FAMILY}`"
+        )));
     }
-    inner
-        .split(',')
-        .map(|item| item.trim().parse().ok())
-        .collect()
-}
-
-fn operand_symbols(
-    operation: OperationRef<'_, '_>,
-    start_index: usize,
-) -> Result<Vec<String>, EmitError> {
-    (start_index..operation.operand_count())
-        .map(|index| operand_symbol(operation, index))
-        .collect()
-}
-
-fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result<String, EmitError> {
-    let operand = operation.operand(index).map_err(|_| {
-        EmitError::new(format!(
-            "{} requires operand {index}",
-            operation_name(operation)
-        ))
-    })?;
-    let owner = OperationResult::try_from(operand).map_err(|_| {
-        EmitError::new(format!(
-            "{} operand {index} must be an op result",
-            operation_name(operation)
-        ))
-    })?;
-    string_attr(owner.owner(), "sym_name")
-}
-
-fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError {
-    EmitError::new(format!(
-        "{} attr `{attr}` is not a {expected}",
-        operation_name(operation)
-    ))
-}
-
-fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String {
-    operation
-        .name()
-        .as_string_ref()
-        .as_str()
-        .unwrap_or("<invalid-operation-name>")
-        .to_owned()
 }
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs
index 764a0d8ec4..c362ff6ef8 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs
@@ -3,38 +3,80 @@
     reason = "generated Rust templates are kept as raw string blocks for copyable output"
 )]
 
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeMap;
 
 use melior::ir::block::BlockLike;
-use melior::ir::operation::{OperationLike, OperationResult};
-use melior::ir::{Attribute, OperationRef};
+use melior::ir::operation::OperationLike;
 
 use crate::emit::rust::{push_format, EmitError, RustSourceFile};
-use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role};
+use crate::ir::{BoltModule, Cpu, Role};
+use crate::protocols::jolt::cpu_attrs::{
+    operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr,
+};
+use crate::protocols::jolt::rust_target_plan::{
+    power_strided_weighted_sum_formula, ScalarExprKind,
+};
+use crate::protocols::jolt::verifier_opening_rows;
+use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan};
+use crate::protocols::jolt::verifier_point_rows;
+use crate::protocols::jolt::verifier_program_rows;
+use crate::protocols::jolt::verifier_relation_outputs::{
+    self, parse_output_eval_family_plan, parse_output_function_family_plan,
+    parse_output_product_family_plan, RelationOutputAst as Stage7RelationOutputAst,
+    RelationOutputEvalFamilyPlan as Stage7RelationOutputEvalFamilyPlan,
+    RelationOutputFieldExprPlan as Stage7RelationOutputFieldExprPlan,
+    RelationOutputFunctionFamilyPlan as Stage7RelationOutputFunctionFamilyPlan,
+    RelationOutputPlan as Stage7RelationOutputPlan,
+    RelationOutputProductFamilyPlan as Stage7RelationOutputProductFamilyPlan,
+    StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan,
+};
+use crate::protocols::jolt::verifier_sumcheck_rows;
+use crate::protocols::jolt::verifier_value_rows;
+use crate::protocols::jolt::verifier_values;
 use crate::schema::verify_cpu_schema;
 
+use super::plan_tokens::{
+    emit_str_array, emit_usize_array, intern_str_array, require_supported_symbol, rust_option_str,
+    rust_str, symbols, verify_count,
+};
+
+const STAGE7_KERNEL_ABIS: &[(&str, &str)] = &[
+    (
+        "jolt.stage7.hamming_weight_claim_reduction",
+        "jolt_stage7_hamming_weight_claim_reduction",
+    ),
+    ("jolt.stage7.batched", "jolt_stage7_batched"),
+];
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Stage7CpuProgram {
     pub role: Role,
+    pub(crate) verifier_plan: Option<VerifierStagePlan>,
     pub params: Stage7Params,
-    pub steps: Vec<Stage7ProgramStepPlan>,
-    pub transcript_squeezes: Vec<Stage7TranscriptSqueezePlan>,
-    pub transcript_absorb_bytes: Vec<Stage7TranscriptAbsorbBytesPlan>,
-    pub opening_inputs: Vec<Stage7OpeningInputPlan>,
-    pub field_constants: Vec<Stage7FieldConstantPlan>,
-    pub field_exprs: Vec<Stage7FieldExprPlan>,
+    pub steps: Vec<verifier_program_rows::CpuProgramStepPlan>,
+    pub transcript_squeezes: Vec<verifier_program_rows::CpuTranscriptSqueezePlan>,
+    pub transcript_absorb_bytes: Vec<verifier_program_rows::CpuTranscriptAbsorbBytesPlan>,
+    pub opening_inputs: Vec<verifier_program_rows::CpuOpeningInputPlan>,
+    pub field_constants: Vec<verifier_value_rows::CpuFieldConstantPlan>,
+    pub field_exprs: Vec<verifier_value_rows::CpuFieldExprPlan>,
+    pub scalar_exprs: Vec<verifier_value_rows::CpuScalarExprPlan>,
     pub kernels: Vec<Stage7KernelPlan>,
-    pub claims: Vec<Stage7SumcheckClaimPlan>,
-    pub batches: Vec<Stage7SumcheckBatchPlan>,
-    pub drivers: Vec<Stage7SumcheckDriverPlan>,
-    pub instance_results: Vec<Stage7SumcheckInstanceResultPlan>,
-    pub evals: Vec<Stage7SumcheckEvalPlan>,
-    pub point_zeros: Vec<Stage7PointZeroPlan>,
-    pub point_slices: Vec<Stage7PointSlicePlan>,
-    pub point_concats: Vec<Stage7PointConcatPlan>,
-    pub opening_claims: Vec<Stage7OpeningClaimPlan>,
-    pub opening_equalities: Vec<Stage7OpeningClaimEqualityPlan>,
-    pub opening_batches: Vec<Stage7OpeningBatchPlan>,
+    pub claims: Vec<verifier_sumcheck_rows::CpuSumcheckClaimPlan>,
+    pub batches: Vec<verifier_sumcheck_rows::CpuSumcheckBatchPlan>,
+    pub drivers: Vec<verifier_sumcheck_rows::CpuSumcheckDriverPlan>,
+    pub instance_results: Vec<verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan>,
+    pub evals: Vec<verifier_sumcheck_rows::CpuSumcheckEvalPlan>,
+    pub relation_output_values: Vec<Stage7StructuredPolynomialEvalPlan>,
+    pub relation_output_eval_families: Vec<Stage7RelationOutputEvalFamilyPlan>,
+    pub relation_output_product_families: Vec<Stage7RelationOutputProductFamilyPlan>,
+    pub relation_output_function_families: Vec<Stage7RelationOutputFunctionFamilyPlan>,
+    pub relation_outputs: Vec<Stage7RelationOutputPlan>,
+    pub point_zeros: Vec<verifier_point_rows::CpuPointZeroPlan>,
+    pub point_slices: Vec<verifier_point_rows::CpuPointSlicePlan>,
+    pub point_concats: Vec<verifier_point_rows::CpuPointConcatPlan>,
+    pub opening_claims: Vec<verifier_opening_rows::CpuOpeningClaimPlan>,
+    pub opening_equalities: Vec<verifier_opening_rows::CpuOpeningClaimEqualityPlan>,
+    pub opening_batches: Vec<verifier_opening_rows::CpuOpeningBatchPlan>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -53,174 +95,152 @@ pub struct Stage7KernelPlan {
     pub abi: String,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7TranscriptSqueezePlan {
-    pub symbol: String,
-    pub label: String,
-    pub kind: String,
-    pub count: usize,
+fn stage7_relation_output_expr(
+    expr: Stage7RelationOutputFieldExprPlan,
+) -> verifier_value_rows::CpuFieldExprPlan {
+    verifier_value_rows::CpuFieldExprPlan::op(expr.symbol, expr.formula, expr.operands)
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7TranscriptAbsorbBytesPlan {
-    pub symbol: String,
-    pub label: String,
-    pub payload: String,
+fn stage7_scalar_expr(
+    expr: Stage7RelationOutputFieldExprPlan,
+) -> verifier_value_rows::CpuScalarExprPlan {
+    verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands)
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7ProgramStepPlan {
-    pub kind: String,
-    pub symbol: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7OpeningInputPlan {
-    pub symbol: String,
-    pub source_stage: String,
-    pub source_claim: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7FieldConstantPlan {
-    pub symbol: String,
-    pub field: String,
-    pub value: usize,
+struct HammingWeightClaimRow {
+    hamming_factor: String,
+    booleanity: String,
+    virtualization: String,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7FieldExprPlan {
-    pub symbol: String,
-    pub kind: String,
-    pub formula: String,
-    pub operand_names: Vec<String>,
-    pub operands: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7SumcheckClaimPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub domain: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-    pub claim: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub claim_value: String,
-    pub input_openings: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7SumcheckBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub round_schedule: Vec<usize>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7SumcheckDriverPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub kernel: Option<String>,
-    pub relation: Option<String>,
-    pub batch: String,
-    pub policy: String,
-    pub round_schedule: Vec<usize>,
-    pub claim_label: String,
-    pub round_label: String,
-    pub num_rounds: usize,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7SumcheckInstanceResultPlan {
-    pub symbol: String,
-    pub source: String,
-    pub claim: String,
-    pub relation: String,
-    pub index: usize,
-    pub point_arity: usize,
-    pub num_rounds: usize,
-    pub round_offset: usize,
-    pub point_order: String,
-    pub degree: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7SumcheckEvalPlan {
-    pub symbol: String,
-    pub source: String,
-    pub name: String,
-    pub index: usize,
-    pub oracle: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7PointZeroPlan {
-    pub symbol: String,
-    pub field: String,
-    pub arity: usize,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7PointSlicePlan {
-    pub symbol: String,
-    pub source: String,
-    pub offset: usize,
-    pub length: usize,
-    pub input: String,
-}
+fn compact_hamming_weight_input_claim(
+    field_exprs: &mut Vec<verifier_value_rows::CpuFieldExprPlan>,
+    scalar_exprs: &mut Vec<verifier_value_rows::CpuScalarExprPlan>,
+    claims: &mut [verifier_sumcheck_rows::CpuSumcheckClaimPlan],
+    opening_inputs: &[verifier_program_rows::CpuOpeningInputPlan],
+) -> Result<(), EmitError> {
+    let Some(claim) = claims
+        .iter_mut()
+        .find(|claim| claim.symbol == "stage7.hamming_weight_claim_reduction.input")
+    else {
+        return Ok(());
+    };
+    let compact_symbol = "stage7.hamming_weight_claim_reduction.input.claim_expr";
+    if claim.claim_value == compact_symbol {
+        return Ok(());
+    }
+    if !claim
+        .claim_value
+        .starts_with("stage7.hamming_weight_claim_reduction.claim_expr")
+    {
+        return Err(EmitError::new(format!(
+            "stage7 hamming-weight input claim has unsupported claim value @{}",
+            claim.claim_value
+        )));
+    }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7PointConcatPlan {
-    pub symbol: String,
-    pub layout: String,
-    pub arity: usize,
-    pub inputs: Vec<String>,
+    let rows = hamming_weight_claim_rows(opening_inputs)?;
+    let row_count = rows.len();
+    let mut operands = Vec::with_capacity(1 + row_count + 3 * row_count);
+    operands.push("stage7.hamming_weight_claim_reduction.gamma".to_owned());
+    operands.extend((0..row_count).map(|_| "stage7.field.one".to_owned()));
+    operands.extend(rows.iter().map(|row| row.hamming_factor.clone()));
+    operands.extend(rows.iter().map(|row| row.booleanity.clone()));
+    operands.extend(rows.iter().map(|row| row.virtualization.clone()));
+
+    field_exprs.retain(|expr| !is_hamming_weight_input_claim_expr(&expr.symbol));
+    scalar_exprs.push(verifier_value_rows::CpuScalarExprPlan::op(
+        compact_symbol.to_owned(),
+        power_strided_weighted_sum_formula(row_count, 3, &[], &[], &[0, 1, 2]),
+        operands,
+    ));
+    compact_symbol.clone_into(&mut claim.claim_value);
+    Ok(())
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7OpeningClaimPlan {
-    pub symbol: String,
-    pub oracle: String,
-    pub domain: String,
-    pub point_arity: usize,
-    pub claim_kind: String,
-    pub point_source: String,
-    pub eval_source: String,
+fn hamming_weight_claim_rows(
+    opening_inputs: &[verifier_program_rows::CpuOpeningInputPlan],
+) -> Result<Vec<HammingWeightClaimRow>, EmitError> {
+    const HAMMING_INPUT: &str = "stage7.input.stage6.hamming_booleanity.HammingWeight";
+    const BOOLEANITY_PREFIX: &str = "stage7.input.stage6.booleanity.";
+    let hamming_factor = opening_inputs
+        .iter()
+        .find(|input| input.symbol == HAMMING_INPUT)
+        .map(|input| input.symbol.clone())
+        .ok_or_else(|| EmitError::new("stage7 hamming-weight input is missing"))?;
+    let mut rows = Vec::new();
+    let mut inputs = opening_inputs
+        .iter()
+        .filter(|input| input.symbol != HAMMING_INPUT);
+    while let Some(booleanity) = inputs.next() {
+        let oracle = booleanity
+            .symbol
+            .strip_prefix(BOOLEANITY_PREFIX)
+            .ok_or_else(|| {
+                EmitError::new(format!(
+                    "stage7 hamming-weight claim expected booleanity input, found @{}",
+                    booleanity.symbol
+                ))
+            })?;
+        let virtualization = inputs.next().ok_or_else(|| {
+            EmitError::new(format!(
+                "stage7 hamming-weight claim missing virtualization input for @{oracle}"
+            ))
+        })?;
+        let (virtual_prefix, row_hamming_factor) = if oracle.starts_with("InstructionRa_") {
+            (
+                "stage7.input.stage6.instruction_ra_virtual.",
+                "stage7.field.one".to_owned(),
+            )
+        } else if oracle.starts_with("BytecodeRa_") {
+            (
+                "stage7.input.stage6.bytecode_read_raf.",
+                "stage7.field.one".to_owned(),
+            )
+        } else if oracle.starts_with("RamRa_") {
+            (
+                "stage7.input.stage6.ram_ra_virtual.",
+                hamming_factor.clone(),
+            )
+        } else {
+            return Err(EmitError::new(format!(
+                "stage7 hamming-weight claim has unsupported RA oracle @{oracle}"
+            )));
+        };
+        let expected_virtualization = format!("{virtual_prefix}{oracle}");
+        if virtualization.symbol != expected_virtualization {
+            return Err(EmitError::new(format!(
+                "stage7 hamming-weight claim expected virtualization input @{expected_virtualization}, found @{}",
+                virtualization.symbol
+            )));
+        }
+        rows.push(HammingWeightClaimRow {
+            hamming_factor: row_hamming_factor,
+            booleanity: booleanity.symbol.clone(),
+            virtualization: virtualization.symbol.clone(),
+        });
+    }
+    if rows.is_empty() {
+        return Err(EmitError::new(
+            "stage7 hamming-weight claim has no RA input rows",
+        ));
+    }
+    Ok(rows)
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7OpeningClaimEqualityPlan {
-    pub symbol: String,
-    pub mode: String,
-    pub lhs: String,
-    pub rhs: String,
+fn is_hamming_weight_input_claim_expr(symbol: &str) -> bool {
+    symbol.starts_with("stage7.hamming_weight_claim_reduction.claim.")
+        || symbol.starts_with("stage7.hamming_weight_claim_reduction.claim_expr")
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Stage7OpeningBatchPlan {
-    pub symbol: String,
-    pub stage: String,
-    pub proof_slot: String,
-    pub policy: String,
-    pub count: usize,
-    pub ordered_claims: Vec<String>,
-    pub claim_operands: Vec<String>,
-}
+verifier_plan::impl_verifier_plan_source_traits!(
+    program = Stage7CpuProgram,
+    absorb = transcript_absorb_bytes,
+    point_zero = verifier_point_rows::CpuPointZeroPlan,
+    relation_output_eval_families = relation_output_eval_families,
+    relation_output_product_families = relation_output_product_families,
+    relation_output_function_families = relation_output_function_families,
+);
 
 pub fn stage7_cpu_program(module: &BoltModule<'_, Cpu>) -> Result<Stage7CpuProgram, EmitError> {
     verify_cpu_schema(module)?;
@@ -234,7 +254,7 @@ pub fn emit_stage7_rust(module: &BoltModule<'_, Cpu>) -> Result<RustSourceFile,
 
     Ok(RustSourceFile {
         filename: program.filename().to_owned(),
-        source: program.emit_source(),
+        source: program.emit_source()?,
     })
 }
 
@@ -247,12 +267,18 @@ impl Stage7CpuProgram {
         let mut opening_inputs = Vec::new();
         let mut field_constants = Vec::new();
         let mut field_exprs = Vec::new();
+        let mut scalar_exprs = Vec::new();
         let mut kernels = Vec::new();
         let mut claims = Vec::new();
         let mut batches = Vec::new();
         let mut drivers = Vec::new();
         let mut instance_results = Vec::new();
         let mut evals = Vec::new();
+        let mut relation_output_values = Vec::new();
+        let mut relation_output_eval_families = Vec::new();
+        let mut relation_output_product_families = Vec::new();
+        let mut relation_output_function_families = Vec::new();
+        let mut relation_output_asts = Vec::new();
         let mut point_zeros = Vec::new();
         let mut point_slices = Vec::new();
         let mut point_concats = Vec::new();
@@ -281,272 +307,221 @@ impl Stage7CpuProgram {
                     });
                 }
                 "cpu.transcript_squeeze" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage7ProgramStepPlan {
-                        kind: "transcript_squeeze".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    transcript_squeezes.push(Stage7TranscriptSqueezePlan {
-                        symbol,
-                        label: string_attr(op, "label")?,
-                        kind: string_attr(op, "kind")?,
-                        count: int_attr(op, "count")?,
-                    });
+                    let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "transcript_squeeze",
+                        squeeze.symbol.clone(),
+                    ));
+                    transcript_squeezes.push(squeeze);
                 }
                 "cpu.transcript_absorb_bytes" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage7ProgramStepPlan {
-                        kind: "transcript_absorb_bytes".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    transcript_absorb_bytes.push(Stage7TranscriptAbsorbBytesPlan {
-                        symbol,
-                        label: string_attr(op, "label")?,
-                        payload: string_attr(op, "payload")?,
-                    });
+                    let absorb = verifier_program_rows::CpuTranscriptAbsorbBytesPlan::from_cpu(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "transcript_absorb_bytes",
+                        absorb.symbol.clone(),
+                    ));
+                    transcript_absorb_bytes.push(absorb);
                 }
                 "cpu.opening_input" => {
-                    opening_inputs.push(Stage7OpeningInputPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source_stage: symbol_attr(op, "source_stage")?,
-                        source_claim: symbol_attr(op, "source_claim")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                    });
+                    opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?);
                 }
                 "cpu.field_const" => {
-                    field_constants.push(Stage7FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: int_attr(op, "value")?,
-                    });
+                    field_constants
+                        .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?);
                 }
                 "cpu.field_zero" => {
-                    field_constants.push(Stage7FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 0,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?);
                 }
                 "cpu.field_one" => {
-                    field_constants.push(Stage7FieldConstantPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        value: 1,
-                    });
+                    field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?);
                 }
                 "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => {
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage7FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: operation_name(op).replace("cpu.field_", "field."),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?);
                 }
                 "cpu.field_pow" => {
-                    let exponent = int_attr(op, "exponent")?;
-                    let operands = operand_symbols(op, 0)?;
-                    field_exprs.push(Stage7FieldExprPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        kind: "op".to_owned(),
-                        formula: format!("field.pow:{exponent}"),
-                        operand_names: operands.clone(),
-                        operands,
-                    });
+                    field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?);
                 }
                 "cpu.sumcheck_claim" => {
-                    claims.push(Stage7SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim(
+                        op,
+                    )?);
                 }
                 "cpu.sumcheck_verify_claim" => {
-                    claims.push(Stage7SumcheckClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        domain: symbol_attr(op, "domain")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                        claim: symbol_attr(op, "claim")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        claim_value: operand_symbol(op, 0)?,
-                        input_openings: operand_symbols(op, 1)?,
-                    });
+                    claims
+                        .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?);
                 }
                 "cpu.sumcheck_batch" => {
-                    batches.push(Stage7SumcheckBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                    });
+                    batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_driver" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage7ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage7SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: Some(symbol_attr(op, "kernel")?),
-                        relation: None,
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_verify" => {
-                    let symbol = string_attr(op, "sym_name")?;
-                    steps.push(Stage7ProgramStepPlan {
-                        kind: "sumcheck_driver".to_owned(),
-                        symbol: symbol.clone(),
-                    });
-                    drivers.push(Stage7SumcheckDriverPlan {
-                        symbol,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        kernel: None,
-                        relation: Some(symbol_attr(op, "relation")?),
-                        batch: operand_symbol(op, 1)?,
-                        policy: string_attr(op, "policy")?,
-                        round_schedule: int_array_attr(op, "round_schedule")?,
-                        claim_label: string_attr(op, "claim_label")?,
-                        round_label: string_attr(op, "round_label")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?;
+                    steps.push(verifier_program_rows::CpuProgramStepPlan::new(
+                        "sumcheck_driver",
+                        driver.symbol.clone(),
+                    ));
+                    drivers.push(driver);
                 }
                 "cpu.sumcheck_instance_result" => {
-                    instance_results.push(Stage7SumcheckInstanceResultPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        claim: symbol_attr(op, "claim")?,
-                        relation: symbol_attr(op, "relation")?,
-                        index: int_attr(op, "index")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        num_rounds: int_attr(op, "num_rounds")?,
-                        round_offset: int_attr(op, "round_offset")?,
-                        point_order: string_attr(op, "point_order")?,
-                        degree: int_attr(op, "degree")?,
-                    });
+                    instance_results
+                        .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?);
                 }
                 "cpu.sumcheck_eval" => {
-                    evals.push(Stage7SumcheckEvalPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        name: symbol_attr(op, "name")?,
-                        index: int_attr(op, "index")?,
-                        oracle: symbol_attr(op, "oracle")?,
+                    evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?);
+                }
+                "cpu.structured_polynomial_eval" => {
+                    relation_output_values.push(
+                        verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?,
+                    );
+                }
+                "cpu.sumcheck_output_eval_family" => {
+                    relation_output_eval_families
+                        .push(parse_output_eval_family_plan("stage7", op)?);
+                }
+                "cpu.sumcheck_output_product_family" => {
+                    relation_output_product_families
+                        .push(parse_output_product_family_plan("stage7", op)?);
+                }
+                "cpu.sumcheck_output_function_family" => {
+                    relation_output_function_families
+                        .push(parse_output_function_family_plan("stage7", op)?);
+                }
+                "cpu.sumcheck_output_claim" => {
+                    relation_output_asts.push(Stage7RelationOutputAst {
+                        relation: symbol_attr(op, "relation")?,
+                        expected_output: operand_symbol(op, 0)?,
+                        polynomial_evals: symbol_array_attr(op, "polynomial_evals")?,
+                        polynomial_eval_operands: operand_symbols(op, 1)?,
                     });
                 }
                 "cpu.point_zero" => {
-                    point_zeros.push(Stage7PointZeroPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        field: symbol_attr(op, "field")?,
-                        arity: int_attr(op, "arity")?,
-                    });
+                    point_zeros.push(verifier_point_rows::CpuPointZeroPlan::from_cpu(op)?);
                 }
                 "cpu.point_slice" => {
-                    point_slices.push(Stage7PointSlicePlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        source: symbol_attr(op, "source")?,
-                        offset: int_attr(op, "offset")?,
-                        length: int_attr(op, "length")?,
-                        input: operand_symbol(op, 0)?,
-                    });
+                    point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?);
                 }
                 "cpu.point_concat" => {
-                    point_concats.push(Stage7PointConcatPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        layout: string_attr(op, "layout")?,
-                        arity: int_attr(op, "arity")?,
-                        inputs: operand_symbols(op, 0)?,
-                    });
+                    point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim" => {
-                    opening_claims.push(Stage7OpeningClaimPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        oracle: symbol_attr(op, "oracle")?,
-                        domain: symbol_attr(op, "domain")?,
-                        point_arity: int_attr(op, "point_arity")?,
-                        claim_kind: string_attr(op, "claim_kind")?,
-                        point_source: operand_symbol(op, 0)?,
-                        eval_source: operand_symbol(op, 1)?,
-                    });
+                    opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?);
                 }
                 "cpu.opening_claim_equal" => {
-                    opening_equalities.push(Stage7OpeningClaimEqualityPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        mode: string_attr(op, "mode")?,
-                        lhs: operand_symbol(op, 0)?,
-                        rhs: operand_symbol(op, 1)?,
-                    });
+                    opening_equalities
+                        .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?);
                 }
                 "cpu.opening_batch" => {
-                    opening_batches.push(Stage7OpeningBatchPlan {
-                        symbol: string_attr(op, "sym_name")?,
-                        stage: symbol_attr(op, "stage")?,
-                        proof_slot: symbol_attr(op, "proof_slot")?,
-                        policy: string_attr(op, "policy")?,
-                        count: int_attr(op, "count")?,
-                        ordered_claims: symbol_array_attr(op, "ordered_claims")?,
-                        claim_operands: operand_symbols(op, 0)?,
-                    });
+                    opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?);
                 }
                 _ => {}
             }
         }
 
-        Ok(Self {
+        let role = module
+            .role()
+            .ok_or_else(|| EmitError::new("missing cpu party role"))?;
+        let is_verifier = role == Role::Verifier;
+        if is_verifier {
+            compact_hamming_weight_input_claim(
+                &mut field_exprs,
+                &mut scalar_exprs,
+                &mut claims,
+                &opening_inputs,
+            )?;
+            for expr in verifier_relation_outputs::lower_eval_family_output_to_weighted_sum(
+                "stage7",
+                "jolt.stage7.hamming_weight_claim_reduction",
+                &mut relation_output_eval_families,
+                &mut relation_output_asts,
+            )? {
+                if ScalarExprKind::from_cpu_attr(&expr.formula).is_ok() {
+                    scalar_exprs.push(stage7_scalar_expr(expr));
+                } else {
+                    field_exprs.push(stage7_relation_output_expr(expr));
+                }
+            }
+        }
+        if role == Role::Prover {
+            verifier_relation_outputs::prune_output_only_field_exprs(
+                &mut field_exprs,
+                claims.iter().map(|claim| claim.claim_value.as_str()),
+                relation_output_asts
+                    .iter()
+                    .map(|claim| claim.expected_output.as_str()),
+            );
+        }
+        let relation_outputs = if role == Role::Verifier {
+            verifier_relation_outputs::resolve_relation_outputs(
+                "stage7",
+                &relation_output_values,
+                &relation_output_eval_families,
+                &relation_output_product_families,
+                &relation_output_function_families,
+                &field_exprs,
+                relation_output_asts,
+            )?
+        } else {
+            Vec::new()
+        };
+        if role == Role::Verifier {
+            scalar_exprs.extend(
+                relation_output_values
+                    .iter()
+                    .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan)
+                    .map(stage7_scalar_expr),
+            );
+        }
+
+        let mut program = Self {
             params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?,
-            role: module
-                .role()
-                .ok_or_else(|| EmitError::new("missing cpu party role"))?,
+            role,
+            verifier_plan: None,
             steps,
             transcript_squeezes,
             transcript_absorb_bytes,
             opening_inputs,
             field_constants,
             field_exprs,
+            scalar_exprs,
             kernels,
             claims,
             batches,
             drivers,
             instance_results,
             evals,
+            relation_output_values,
+            relation_output_eval_families,
+            relation_output_product_families,
+            relation_output_function_families,
+            relation_outputs,
             point_zeros,
             point_slices,
             point_concats,
             opening_claims,
             opening_equalities,
             opening_batches,
-        })
+        };
+        if is_verifier {
+            program.verifier_plan = Some(program.plan_verifier()?);
+        }
+        Ok(program)
+    }
+
+    fn plan_verifier(&self) -> Result<VerifierStagePlan, EmitError> {
+        verifier_plan::plan_verifier_stage_from_cpu_sources(self)
+    }
+
+    fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> {
+        self.verifier_plan
+            .as_ref()
+            .ok_or_else(|| EmitError::new("missing stage7 verifier plan"))
     }
 
     fn verify_supported_target(&self) -> Result<(), EmitError> {
@@ -555,13 +530,19 @@ impl Stage7CpuProgram {
         require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?;
         self.verify_transcript_steps()?;
         self.verify_field_flow()?;
-        self.verify_claim_batches()?;
         match self.role {
             Role::Prover => {
+                self.verify_claim_batches()?;
                 self.verify_kernel_definitions()?;
                 self.verify_prover_driver_bindings()?;
             }
-            Role::Verifier => self.verify_verifier_driver_bindings()?,
+            Role::Verifier => {
+                self.verifier_plan()?.verify_sumcheck_flow("stage7")?;
+                self.verify_verifier_driver_bindings()?;
+            }
+        }
+        if self.role == Role::Verifier {
+            self.verify_relation_outputs()?;
         }
         self.verify_opening_flow()
     }
@@ -599,23 +580,41 @@ impl Stage7CpuProgram {
         for constant in &self.field_constants {
             require_supported_symbol("field constant field", &constant.field, "bn254_fr")?;
         }
-        let field_values = self.field_value_symbols();
-        for expr in &self.field_exprs {
-            verify_count(
-                "field expr operands",
-                &expr.symbol,
-                expr.operand_names.len(),
-                expr.operands.len(),
-            )?;
-            for operand in &expr.operands {
-                if !field_values.contains(operand) {
-                    return Err(EmitError::new(format!(
-                        "field expr @{} references missing field value @{operand}",
-                        expr.symbol
-                    )));
-                }
-            }
-        }
+        let verifier_plan = if self.role == Role::Verifier {
+            Some(self.verifier_plan()?)
+        } else {
+            None
+        };
+        let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values());
+        let field_values = verifier_scalar_values.as_ref().map_or_else(
+            || self.cpu_field_value_sources(),
+            |values| values.source_set(),
+        );
+        let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values());
+        let verifier_point_values = verifier_plan.map(|plan| plan.point_values());
+        let point_values = verifier_point_values
+            .as_ref()
+            .map(|values| values.source_set());
+        super::plan_tokens::verify_field_expr_flow(
+            super::plan_tokens::FieldExprFlowVerification {
+                cpu_exprs: &self.field_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+            },
+        )?;
+        super::plan_tokens::verify_scalar_expr_flow(
+            super::plan_tokens::ScalarExprFlowVerification {
+                stage: "stage7",
+                cpu_exprs: &self.scalar_exprs,
+                verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()),
+                field_values: &field_values,
+                verifier_field_values: verifier_scalar_values.as_ref(),
+                field_vector_values: field_vector_values.as_ref(),
+                point_values: point_values.as_ref(),
+                verifier_point_values: verifier_point_values.as_ref(),
+            },
+        )?;
         for claim in &self.claims {
             if !field_values.contains(&claim.claim_value) {
                 return Err(EmitError::new(format!(
@@ -627,19 +626,53 @@ impl Stage7CpuProgram {
         Ok(())
     }
 
-    fn field_value_symbols(&self) -> BTreeSet<String> {
-        let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
-        values.extend(symbols(
+    fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet {
+        let mut values = verifier_values::VerifierScalarSourceSet::default();
+        values.extend(
+            self.opening_inputs.iter().map(|input| &input.symbol),
+            verifier_values::VerifierScalarSourceKind::OpeningInput,
+        );
+        values.extend(
             self.field_constants.iter().map(|constant| &constant.symbol),
-        ));
-        values.extend(symbols(
+            verifier_values::VerifierScalarSourceKind::FieldConstant,
+        );
+        values.extend(
             self.transcript_squeezes
                 .iter()
                 .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar"))
                 .map(|squeeze| &squeeze.symbol),
-        ));
-        values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol)));
-        values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol)));
+            verifier_values::VerifierScalarSourceKind::TranscriptScalar,
+        );
+        values.extend(
+            self.field_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::FieldExpr,
+        );
+        values.extend(
+            self.scalar_exprs.iter().map(|expr| &expr.symbol),
+            verifier_values::VerifierScalarSourceKind::ScalarExpr,
+        );
+        values.extend(
+            self.evals.iter().map(|eval| &eval.symbol),
+            verifier_values::VerifierScalarSourceKind::SumcheckEval,
+        );
+        values.extend(
+            self.relation_output_eval_families
+                .iter()
+                .map(|family| &family.symbol),
+            verifier_values::VerifierScalarSourceKind::OutputEvalFamily,
+        );
+        values.extend(
+            self.relation_output_product_families
+                .iter()
+                .map(|family| &family.symbol),
+            verifier_values::VerifierScalarSourceKind::OutputProductFamily,
+        );
+        values.extend(
+            self.relation_output_function_families
+                .iter()
+                .map(|family| &family.symbol),
+            verifier_values::VerifierScalarSourceKind::OutputFunctionFamily,
+        );
         values
     }
 
@@ -657,18 +690,12 @@ impl Stage7CpuProgram {
                     kernel.symbol, kernel.kind
                 )));
             }
-            let expected_abi = match kernel.relation.as_str() {
-                "jolt.stage7.hamming_weight_claim_reduction" => {
-                    "jolt_stage7_hamming_weight_claim_reduction"
-                }
-                "jolt.stage7.batched" => "jolt_stage7_batched",
-                _ => {
-                    return Err(EmitError::new(format!(
-                        "unsupported stage7 kernel relation @{}",
-                        kernel.relation
-                    )));
-                }
-            };
+            let expected_abi = stage7_kernel_abi(&kernel.relation).ok_or_else(|| {
+                EmitError::new(format!(
+                    "unsupported stage7 kernel relation @{}",
+                    kernel.relation
+                ))
+            })?;
             if kernel.abi != expected_abi {
                 return Err(EmitError::new(format!(
                     "stage7 kernel @{} ABI `{}` does not match relation @{}",
@@ -774,11 +801,6 @@ impl Stage7CpuProgram {
                 "verifier stage7 program must not contain kernels",
             ));
         }
-        let batches: BTreeMap<_, _> = self
-            .batches
-            .iter()
-            .map(|batch| (batch.symbol.as_str(), batch))
-            .collect();
         for claim in &self.claims {
             if claim.kernel.is_some() || claim.relation.is_none() {
                 return Err(EmitError::new(format!(
@@ -794,29 +816,18 @@ impl Stage7CpuProgram {
                     driver.symbol
                 )));
             }
-            let batch = batches.get(driver.batch.as_str()).ok_or_else(|| {
-                EmitError::new(format!(
-                    "sumcheck driver @{} references missing batch @{}",
-                    driver.symbol, driver.batch
-                ))
-            })?;
-            verify_count(
-                "sumcheck driver round_schedule",
-                &driver.symbol,
-                driver.num_rounds,
-                driver.round_schedule.iter().sum(),
-            )?;
-            if driver.round_schedule != batch.round_schedule {
-                return Err(EmitError::new(format!(
-                    "sumcheck driver @{} round_schedule differs from batch @{}",
-                    driver.symbol, batch.symbol
-                )));
-            }
         }
         Ok(())
     }
 
+    fn verify_relation_outputs(&self) -> Result<(), EmitError> {
+        self.verifier_plan()?.verify_relation_outputs("stage7")
+    }
+
     fn verify_opening_flow(&self) -> Result<(), EmitError> {
+        if self.role == Role::Verifier {
+            return self.verifier_plan()?.verify_opening_flow("stage7");
+        }
         let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol));
         point_sources.extend(symbols(
             self.instance_results
@@ -852,7 +863,7 @@ impl Stage7CpuProgram {
                 }
             }
         }
-        let eval_sources = self.field_value_symbols();
+        let eval_sources = self.cpu_field_value_sources();
         let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol));
         opening_sources.extend(symbols(
             self.opening_claims.iter().map(|claim| &claim.symbol),
@@ -951,7 +962,7 @@ impl Stage7CpuProgram {
         }
     }
 
-    fn emit_source(&self) -> String {
+    fn emit_source(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         source.push_str("#![allow(dead_code)]\n\n");
         match self.role {
@@ -967,10 +978,10 @@ impl Stage7CpuProgram {
             }
         }
         source.push('\n');
-        source.push_str(&self.emit_constants());
+        source.push_str(&self.emit_constants()?);
         source.push('\n');
         source.push_str(self.emit_entrypoint());
-        source
+        Ok(source)
     }
 
     fn emit_prover_imports() -> &'static str {
@@ -984,9 +995,8 @@ impl Stage7CpuProgram {
     }
 
     fn emit_verifier_imports() -> &'static str {
-        "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, reverse_slice};\n\
-         use jolt_field::{Field, Fr, RingCore};\n\
-         use jolt_poly::EqPolynomial;\n\
+        "use bolt_verifier_runtime::find_plan;\n\
+         use jolt_field::{Field, Fr};\n\
          use jolt_sumcheck::SumcheckError;\n\
          use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};"
     }
@@ -1205,26 +1215,36 @@ pub struct Stage7CpuProgramPlan {
     }
 
     fn emit_verifier_type_aliases() -> &'static str {
-        r#"pub type Stage7NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage7SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage7ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage7ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage7Proof<F> = super::common::StageProof<F>;
-pub type Stage7OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-
-pub use super::common::{
-    FieldConstantPlan as Stage7FieldConstantPlan, FieldExprPlan as Stage7FieldExprPlan,
+        r#"pub type Stage7NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage7SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage7ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage7ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage7Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage7OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage7CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan<Stage7RelationKind>;
+pub type Stage7SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage7RelationKind>;
+pub type Stage7SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage7RelationKind>;
+pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage7RelationKind>;
+pub type Stage7RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage7RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage7ClaimKind, FieldConstantPlan as Stage7FieldConstantPlan,
+    FieldExprKind as Stage7FieldExprKind,
+    FieldExprPlan as Stage7FieldExprPlan,
+    ScalarExprKind as Stage7ScalarExprKind,
+    ScalarExprPlan as Stage7ScalarExprPlan,
     KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan,
-    PointConcatPlan as Stage7PointConcatPlan, PointSlicePlan as Stage7PointSlicePlan,
-    PointZeroPlan as Stage7PointZeroPlan, ProgramStepPlan as Stage7ProgramStepPlan,
-    StageParams as Stage7Params, StageProgramPlan as Stage7CpuProgramPlan,
+    OpeningEqualityMode as Stage7OpeningEqualityMode, PointExprKind as Stage7PointExprKind,
+    PointExprPlan as Stage7PointExprPlan, ProgramStepKind as Stage7ProgramStepKind,
+    ProgramStepPlan as Stage7ProgramStepPlan,
+    StageParams as Stage7Params,
     SumcheckBatchPlan as Stage7SumcheckBatchPlan,
-    SumcheckClaimPlan as Stage7SumcheckClaimPlan, SumcheckDriverPlan as Stage7SumcheckDriverPlan,
     SumcheckEvalPlan as Stage7SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage7SumcheckInstanceResultPlan,
     TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan,
+    TranscriptSqueezeKind as Stage7TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage7TranscriptSqueezePlan,
 };
 "#
@@ -1246,24 +1266,46 @@ pub enum VerifyStage7Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage7RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error);
 "#,
         );
         source
     }
 
-    fn emit_constants(&self) -> String {
-        let mut source = self.emit_shared_constants();
+    fn emit_constants(&self) -> Result<String, EmitError> {
+        let mut source = self.emit_shared_constants()?;
         source.push_str(&self.emit_kernel_constants());
-        source.push_str(&self.emit_sumcheck_claim_constants());
-        source.push_str(&self.emit_sumcheck_batch_constants());
-        source.push_str(&self.emit_sumcheck_driver_constants());
-        source.push_str(&self.emit_tail_constants());
+        source.push_str(&self.emit_sumcheck_claim_constants()?);
+        source.push_str(&self.emit_sumcheck_batch_constants()?);
+        source.push_str(&self.emit_sumcheck_driver_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_verifier_relation_output_constants()?);
+        }
+        source.push_str(&self.emit_tail_constants()?);
+        let relation_outputs_field = if self.role == Role::Verifier {
+            "    relation_outputs: STAGE7_RELATION_OUTPUTS,\n"
+        } else {
+            ""
+        };
+        let indexed_eval_families_field = if self.role == Role::Verifier {
+            "    indexed_eval_families: &[],\n"
+        } else {
+            ""
+        };
+        let scalar_exprs_field = if self.role == Role::Verifier {
+            "    scalar_exprs: STAGE7_SCALAR_EXPRS,\n"
+        } else {
+            ""
+        };
+        let point_exprs_field = if self.role == Role::Verifier {
+            "    point_exprs: STAGE7_POINT_EXPRS,\n"
+        } else {
+            "    point_zeros: STAGE7_POINT_ZEROS,\n    point_slices: STAGE7_POINT_SLICES,\n    point_concats: STAGE7_POINT_CONCATS,\n"
+        };
         push_format(
             &mut source,
             format_args!(
@@ -1276,15 +1318,16 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                  \x20   opening_inputs: STAGE7_OPENING_INPUTS,\n\
                  \x20   field_constants: STAGE7_FIELD_CONSTANTS,\n\
                  \x20   field_exprs: STAGE7_FIELD_EXPRS,\n\
+                 {scalar_exprs_field}\
                  \x20   kernels: STAGE7_KERNELS,\n\
                  \x20   claims: STAGE7_SUMCHECK_CLAIMS,\n\
                  \x20   batches: STAGE7_SUMCHECK_BATCHES,\n\
                  \x20   drivers: STAGE7_SUMCHECK_DRIVERS,\n\
                  \x20   instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS,\n\
                  \x20   evals: STAGE7_SUMCHECK_EVALS,\n\
-                 \x20   point_zeros: STAGE7_POINT_ZEROS,\n\
-                 \x20   point_slices: STAGE7_POINT_SLICES,\n\
-                 \x20   point_concats: STAGE7_POINT_CONCATS,\n\
+                 {indexed_eval_families_field}\
+                 {relation_outputs_field}\
+                 {point_exprs_field}\
                  \x20   opening_claims: STAGE7_OPENING_CLAIMS,\n\
                  \x20   opening_equalities: STAGE7_OPENING_EQUALITIES,\n\
                  \x20   opening_batches: STAGE7_OPENING_BATCHES,\n\
@@ -1293,70 +1336,97 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                 rust_str(self.role_label())
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_shared_constants(&self) -> String {
+    fn emit_shared_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE7_PARAMS: Stage7Params = Stage7Params {{\n\
-                 \x20   field: {},\n\
-                 \x20   pcs: {},\n\
-                 \x20   transcript: {},\n\
-                 }};\n",
+                "pub const STAGE7_PARAMS: Stage7Params = Stage7Params {{ field: {}, pcs: {}, transcript: {} }};\n",
                 rust_str(&self.params.field),
                 rust_str(&self.params.pcs),
                 rust_str(&self.params.transcript)
             ),
         );
-        source.push_str(&self.emit_program_step_constants());
-        source.push_str(&self.emit_transcript_squeeze_constants());
-        source.push_str(&self.emit_transcript_absorb_bytes_constants());
-        source.push_str(&self.emit_opening_input_constants());
+        source.push_str(&self.emit_program_step_constants()?);
+        source.push_str(&self.emit_transcript_squeeze_constants()?);
+        source.push_str(&self.emit_transcript_absorb_bytes_constants()?);
+        source.push_str(&self.emit_opening_input_constants()?);
         source.push_str(&self.emit_field_constant_constants());
-        source.push_str(&self.emit_field_expr_constants());
-        source
+        source.push_str(&self.emit_field_expr_constants()?);
+        if self.role == Role::Verifier {
+            source.push_str(&self.emit_scalar_expr_constants()?);
+        }
+        Ok(source)
     }
 
-    fn emit_program_step_constants(&self) -> String {
+    fn emit_program_step_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_program_step_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.steps,
+            ));
+        }
         let steps = self
             .steps
             .iter()
             .map(|step| {
-                format!(
+                Ok(format!(
                     "    Stage7ProgramStepPlan {{ kind: {}, symbol: {} }},",
-                    rust_str(&step.kind),
+                    super::plan_tokens::role_program_step_kind_expr(
+                        "Stage7", &self.role, &step.kind
+                    )?,
                     rust_str(&step.symbol),
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE7_PROGRAM_STEPS: &[Stage7ProgramStepPlan] = &[\n{steps}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE7_PROGRAM_STEPS: &[Stage7ProgramStepPlan] = &[\n{steps}\n];\n\n"
+        ))
     }
 
-    fn emit_transcript_squeeze_constants(&self) -> String {
+    fn emit_transcript_squeeze_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_transcript_squeeze_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.transcript_squeezes,
+            ));
+        }
         let squeezes = self
             .transcript_squeezes
             .iter()
             .map(|squeeze| {
-                format!(
+                Ok(format!(
                     "    Stage7TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},",
                     rust_str(&squeeze.symbol),
                     rust_str(&squeeze.label),
-                    rust_str(&squeeze.kind),
+                    super::plan_tokens::role_transcript_squeeze_kind_expr("Stage7", &self.role, &squeeze.kind)?,
                     squeeze.count,
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE7_TRANSCRIPT_SQUEEZES: &[Stage7TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_transcript_absorb_bytes_constants(&self) -> String {
+    fn emit_transcript_absorb_bytes_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_transcript_absorb_bytes_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.transcript_absorb_bytes,
+            ));
+        }
         let absorbs = self
             .transcript_absorb_bytes
             .iter()
@@ -1370,17 +1440,25 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE7_TRANSCRIPT_ABSORB_BYTES: &[Stage7TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_opening_input_constants(&self) -> String {
+    fn emit_opening_input_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_input_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.opening_inputs,
+            ));
+        }
         let inputs = self
             .opening_inputs
             .iter()
             .map(|input| {
-                format!(
+                Ok(format!(
                     "    Stage7OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},",
                     rust_str(&input.symbol),
                     rust_str(&input.source_stage),
@@ -1388,12 +1466,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                     rust_str(&input.oracle),
                     rust_str(&input.domain),
                     input.point_arity,
-                    rust_str(&input.claim_kind)
-                )
+                    super::plan_tokens::role_claim_kind_expr("Stage7", &self.role, &input.claim_kind)?
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE7_OPENING_INPUTS: &[Stage7OpeningInputPlan] = &[\n{inputs}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE7_OPENING_INPUTS: &[Stage7OpeningInputPlan] = &[\n{inputs}\n];\n\n"
+        ))
     }
 
     fn emit_field_constant_constants(&self) -> String {
@@ -1415,31 +1495,16 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
         )
     }
 
-    fn emit_field_expr_constants(&self) -> String {
+    fn emit_field_expr_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let rows = self
-                .field_exprs
-                .chunks(8)
-                .map(|chunk| {
-                    let exprs = chunk
-                        .iter()
-                        .map(|expr| {
-                            format!(
-                                "stage7_field_expr!({}, {}, {})",
-                                rust_str(&expr.symbol),
-                                rust_str(&expr.formula),
-                                rust_str(&expr.operands.join("|"))
-                            )
-                        })
-                        .collect::<Vec<_>>()
-                        .join(", ");
-                    format!("    {exprs},")
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "macro_rules! stage7_field_expr {{\n    ($symbol:literal, $formula:literal, $operands:literal) => {{\n        Stage7FieldExprPlan {{ symbol: $symbol, kind: \"op\", formula: $formula, operands: $operands }}\n    }};\n}}\n\n#[rustfmt::skip]\npub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{rows}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_field_expr_constants_chunked(
+                "Stage7",
+                "STAGE7",
+                "stage7_field_expr",
+                &plan.field_exprs,
+                8,
+            ));
         }
 
         let mut source = String::new();
@@ -1481,7 +1546,18 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                 "pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{exprs}\n];\n"
             ),
         );
-        source
+        Ok(source)
+    }
+
+    fn emit_scalar_expr_constants(&self) -> Result<String, EmitError> {
+        let plan = self.verifier_plan()?;
+        Ok(verifier_plan::emit_scalar_expr_constants_chunked(
+            "Stage7",
+            "STAGE7",
+            "stage7_scalar_expr",
+            &plan.scalar_exprs,
+            8,
+        ))
     }
 
     fn emit_kernel_constants(&self) -> String {
@@ -1503,31 +1579,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
         format!("pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[\n{kernels}\n];\n\n")
     }
 
-    fn emit_sumcheck_claim_constants(&self) -> String {
+    fn emit_sumcheck_claim_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let claims = self
-                .claims
-                .iter()
-                .map(|claim| {
-                    format!(
-                        "    Stage7SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},",
-                        rust_str(&claim.symbol),
-                        rust_str(&claim.stage),
-                        rust_str(&claim.domain),
-                        claim.num_rounds,
-                        claim.degree,
-                        rust_str(&claim.claim),
-                        rust_option_str(claim.kernel.as_deref()),
-                        rust_option_str(claim.relation.as_deref()),
-                        rust_str(&claim.claim_value),
-                        rust_str(&claim.input_openings.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[\n{claims}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_claim_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.claims,
+            ));
         }
 
         let mut source = String::new();
@@ -1542,7 +1601,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
             .iter()
             .enumerate()
             .map(|(index, claim)| {
-                format!(
+                Ok(format!(
                     "    Stage7SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: STAGE7_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.stage),
@@ -1551,11 +1610,15 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                     claim.degree,
                     rust_str(&claim.claim),
                     rust_option_str(claim.kernel.as_deref()),
-                    rust_option_str(claim.relation.as_deref()),
+                    super::plan_tokens::role_optional_relation_kind_expr(
+                        "Stage7",
+                        &self.role,
+                        claim.relation.as_deref()
+                    )?,
                     rust_str(&claim.claim_value)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
         push_format(
             &mut source,
@@ -1563,45 +1626,17 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                 "pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[\n{claims}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_sumcheck_batch_constants(&self) -> String {
+    fn emit_sumcheck_batch_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let mut source = String::new();
-            for (index, batch) in self.batches.iter().enumerate() {
-                source.push_str(&emit_usize_array(
-                    &format!("STAGE7_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"),
-                    &batch.round_schedule,
-                ));
-            }
-            let batches = self
-                .batches
-                .iter()
-                .enumerate()
-                .map(|(index, batch)| {
-                    format!(
-                        "    Stage7SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE7_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
-                        rust_str(&batch.symbol),
-                        rust_str(&batch.stage),
-                        rust_str(&batch.proof_slot),
-                        rust_str(&batch.policy),
-                        batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|")),
-                        rust_str(&batch.claim_label),
-                        rust_str(&batch.round_label)
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            push_format(
-                &mut source,
-                format_args!(
-                    "pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[\n{batches}\n];\n"
-                ),
-            );
-            return source;
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_batch_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.batches,
+            ));
         }
 
         let mut source = String::new();
@@ -1643,10 +1678,18 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                 "pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[\n{batches}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_sumcheck_driver_constants(&self) -> String {
+    fn emit_sumcheck_driver_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_driver_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.drivers,
+            ));
+        }
         let mut source = String::new();
         for (index, driver) in self.drivers.iter().enumerate() {
             source.push_str(&emit_usize_array(
@@ -1659,22 +1702,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
             .iter()
             .enumerate()
             .map(|(index, driver)| {
-                format!(
+                Ok(format!(
                     "    Stage7SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: {}, relation: {}, batch: {}, policy: {}, round_schedule: STAGE7_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},",
                     rust_str(&driver.symbol),
                     rust_str(&driver.stage),
                     rust_str(&driver.proof_slot),
                     rust_option_str(driver.kernel.as_deref()),
-                    rust_option_str(driver.relation.as_deref()),
+                    super::plan_tokens::role_optional_relation_kind_expr(
+                        "Stage7",
+                        &self.role,
+                        driver.relation.as_deref()
+                    )?,
                     rust_str(&driver.batch),
                     rust_str(&driver.policy),
                     rust_str(&driver.claim_label),
                     rust_str(&driver.round_label),
                     driver.num_rounds,
                     driver.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
         push_format(
             &mut source,
@@ -1682,46 +1729,59 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                 "pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[\n{drivers}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_tail_constants(&self) -> String {
+    fn emit_tail_constants(&self) -> Result<String, EmitError> {
         let mut source = String::new();
-        source.push_str(&self.emit_sumcheck_instance_result_constants());
+        source.push_str(&self.emit_sumcheck_instance_result_constants()?);
         source.push_str(&self.emit_sumcheck_eval_constants());
-        source.push_str(&self.emit_point_zero_constants());
-        source.push_str(&self.emit_point_slice_constants());
-        source.push_str(&self.emit_point_concat_constants());
-        source.push_str(&self.emit_opening_claim_constants());
-        source.push_str(&self.emit_opening_claim_equality_constants());
-        source.push_str(&self.emit_opening_batch_constants());
-        source
+        source.push_str(&self.emit_point_constants()?);
+        source.push_str(&self.emit_opening_claim_constants()?);
+        source.push_str(&self.emit_opening_claim_equality_constants()?);
+        source.push_str(&self.emit_opening_batch_constants()?);
+        Ok(source)
     }
 
-    fn emit_sumcheck_instance_result_constants(&self) -> String {
+    fn emit_sumcheck_instance_result_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_sumcheck_instance_result_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.instance_results,
+            ));
+        }
         let instances = self
             .instance_results
             .iter()
             .map(|instance| {
-                format!(
+                Ok(format!(
                     "    Stage7SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},",
                     rust_str(&instance.symbol),
                     rust_str(&instance.source),
                     rust_str(&instance.claim),
-                    rust_str(&instance.relation),
+                    super::plan_tokens::role_relation_kind_expr(
+                        "Stage7",
+                        &self.role,
+                        &instance.relation
+                    )?,
                     instance.index,
                     instance.point_arity,
                     instance.num_rounds,
                     instance.round_offset,
-                    rust_str(&instance.point_order),
+                    super::plan_tokens::role_sumcheck_point_order_expr(
+                        &self.role,
+                        &instance.point_order
+                    )?,
                     instance.degree
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n"
-        )
+        ))
     }
 
     fn emit_sumcheck_eval_constants(&self) -> String {
@@ -1733,7 +1793,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                     .iter()
                     .map(|eval| {
                         format!(
-                            "stage7_sumcheck_eval!({}, {}, {}, {}, {})",
+                            "stage7_sumcheck_eval({}, {}, {}, {}, {})",
                             rust_str(&eval.symbol),
                             rust_str(&eval.source),
                             rust_str(&eval.name),
@@ -1748,11 +1808,29 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
             .collect::<Vec<_>>()
             .join("\n");
         format!(
-            "macro_rules! stage7_sumcheck_eval {{\n    ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => {{\n        Stage7SumcheckEvalPlan {{ symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle }}\n    }};\n}}\n\n#[rustfmt::skip]\npub const STAGE7_SUMCHECK_EVALS: &[Stage7SumcheckEvalPlan] = &[\n{rows}\n];\n\n"
+            "const fn stage7_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage7SumcheckEvalPlan {{\n    Stage7SumcheckEvalPlan {{ symbol, source, name, index, oracle }}\n}}\n\n#[rustfmt::skip]\npub const STAGE7_SUMCHECK_EVALS: &[Stage7SumcheckEvalPlan] = &[\n{rows}\n];\n\n"
         )
     }
 
-    fn emit_point_zero_constants(&self) -> String {
+    fn emit_verifier_relation_output_constants(&self) -> Result<String, EmitError> {
+        super::relation_outputs::emit_verifier_relation_output_constants(
+            "Stage7",
+            &self.role,
+            &self.relation_outputs,
+        )
+    }
+
+    fn emit_point_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_point_expr_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.point_exprs,
+            ));
+        }
+
+        let mut source = String::new();
         let zeros = self
             .point_zeros
             .iter()
@@ -1766,10 +1844,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!("pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[\n{zeros}\n];\n\n")
-    }
-
-    fn emit_point_slice_constants(&self) -> String {
+        push_format(
+            &mut source,
+            format_args!(
+                "pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[\n{zeros}\n];\n\n"
+            ),
+        );
         let slices = self
             .point_slices
             .iter()
@@ -1785,31 +1865,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
             })
             .collect::<Vec<_>>()
             .join("\n");
-        format!("pub const STAGE7_POINT_SLICES: &[Stage7PointSlicePlan] = &[\n{slices}\n];\n\n")
-    }
-
-    fn emit_point_concat_constants(&self) -> String {
-        if self.role == Role::Verifier {
-            let concats = self
-                .point_concats
-                .iter()
-                .map(|concat| {
-                    format!(
-                        "    Stage7PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},",
-                        rust_str(&concat.symbol),
-                        rust_str(&concat.layout),
-                        concat.arity,
-                        rust_str(&concat.inputs.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE7_POINT_CONCATS: &[Stage7PointConcatPlan] = &[\n{concats}\n];\n"
-            );
-        }
-
-        let mut source = String::new();
+        push_format(
+            &mut source,
+            format_args!(
+                "pub const STAGE7_POINT_SLICES: &[Stage7PointSlicePlan] = &[\n{slices}\n];\n\n"
+            ),
+        );
         for (index, concat) in self.point_concats.iter().enumerate() {
             source.push_str(&emit_str_array(
                 &format!("STAGE7_POINT_CONCAT_{index}_INPUTS"),
@@ -1836,72 +1897,76 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                 "pub const STAGE7_POINT_CONCATS: &[Stage7PointConcatPlan] = &[\n{concats}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
-    fn emit_opening_claim_constants(&self) -> String {
+    fn emit_opening_claim_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.opening_claims,
+            ));
+        }
         let claims = self
             .opening_claims
             .iter()
             .map(|claim| {
-                format!(
+                Ok(format!(
                     "    Stage7OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},",
                     rust_str(&claim.symbol),
                     rust_str(&claim.oracle),
                     rust_str(&claim.domain),
                     claim.point_arity,
-                    rust_str(&claim.claim_kind),
+                    super::plan_tokens::role_claim_kind_expr("Stage7", &self.role, &claim.claim_kind)?,
                     rust_str(&claim.point_source),
                     rust_str(&claim.eval_source)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!("pub const STAGE7_OPENING_CLAIMS: &[Stage7OpeningClaimPlan] = &[\n{claims}\n];\n\n")
+        Ok(format!(
+            "pub const STAGE7_OPENING_CLAIMS: &[Stage7OpeningClaimPlan] = &[\n{claims}\n];\n\n"
+        ))
     }
 
-    fn emit_opening_claim_equality_constants(&self) -> String {
+    fn emit_opening_claim_equality_constants(&self) -> Result<String, EmitError> {
+        if self.role == Role::Verifier {
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_claim_equality_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.opening_equalities,
+            ));
+        }
         let equalities = self
             .opening_equalities
             .iter()
             .map(|equality| {
-                format!(
+                Ok(format!(
                     "    Stage7OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},",
                     rust_str(&equality.symbol),
-                    rust_str(&equality.mode),
+                    super::plan_tokens::role_opening_equality_mode_expr("Stage7", &self.role, &equality.mode)?,
                     rust_str(&equality.lhs),
                     rust_str(&equality.rhs)
-                )
+                ))
             })
-            .collect::<Vec<_>>()
+            .collect::<Result<Vec<_>, EmitError>>()?
             .join("\n");
-        format!(
+        Ok(format!(
             "pub const STAGE7_OPENING_EQUALITIES: &[Stage7OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n"
-        )
+        ))
     }
 
-    fn emit_opening_batch_constants(&self) -> String {
+    fn emit_opening_batch_constants(&self) -> Result<String, EmitError> {
         if self.role == Role::Verifier {
-            let batches = self
-                .opening_batches
-                .iter()
-                .map(|batch| {
-                    format!(
-                        "    Stage7OpeningBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {} }},",
-                        rust_str(&batch.symbol),
-                        rust_str(&batch.stage),
-                        rust_str(&batch.proof_slot),
-                        rust_str(&batch.policy),
-                        batch.count,
-                        rust_str(&batch.ordered_claims.join("|")),
-                        rust_str(&batch.claim_operands.join("|"))
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n");
-            return format!(
-                "pub const STAGE7_OPENING_BATCHES: &[Stage7OpeningBatchPlan] = &[\n{batches}\n];\n"
-            );
+            let plan = self.verifier_plan()?;
+            return Ok(verifier_plan::emit_opening_batch_constants(
+                "Stage7",
+                "STAGE7",
+                &plan.opening_batches,
+            ));
         }
 
         let mut source = String::new();
@@ -1937,7 +2002,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
                 "pub const STAGE7_OPENING_BATCHES: &[Stage7OpeningBatchPlan] = &[\n{batches}\n];\n"
             ),
         );
-        source
+        Ok(source)
     }
 
     fn emit_entrypoint(&self) -> &'static str {
@@ -1994,20 +2059,19 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
-    store.seed_point_zeros(program.point_zeros);
     let mut artifacts = Stage7ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage7ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage7Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage7_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "transcript_absorb_bytes" => {
+            Stage7ProgramStepKind::TranscriptAbsorbBytes => {
                 let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or(
                     VerifyStage7Error::MissingValue {
                         symbol: step.symbol,
@@ -2015,7 +2079,7 @@ where
                 )?;
                 absorb_stage7_bytes(absorb, transcript);
             }
-            "sumcheck_driver" => {
+            Stage7ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage7Error::MissingProof {
                         driver: step.symbol,
@@ -2029,12 +2093,6 @@ where
                     &mut artifacts,
                 )?;
             }
-            _ => {
-                return Err(VerifyStage7Error::InvalidProof {
-                    driver: step.symbol,
-                    reason: "unsupported stage7 program step",
-                });
-            }
         }
     }
     artifacts
@@ -2050,7 +2108,7 @@ pub fn stage7_verifier_program() -> &'static Stage7VerifierProgramPlan {
 fn verify_stage7_squeeze<T>(
     program: &'static Stage7VerifierProgramPlan,
     squeeze: &'static Stage7TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage7ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage7Error>
@@ -2066,7 +2124,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage7Error::from)?;
     artifacts.challenge_vectors.push(Stage7ChallengeVector {
         symbol: squeeze.symbol,
@@ -2090,7 +2148,7 @@ fn verify_stage7_driver<T>(
     program: &'static Stage7VerifierProgramPlan,
     driver: &'static Stage7SumcheckDriverPlan,
     proof: &Stage7Proof<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage7ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage7Error>
@@ -2103,12 +2161,17 @@ where
         .ok_or(VerifyStage7Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage7Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage7.batched" => {
+        Stage7RelationKind::Stage7Batched => {
             verify_batched_stage7(program, driver, proof, store, transcript)?
         }
-        _ => return Err(VerifyStage7Error::UnsupportedRelation { relation }),
+        relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -2118,25 +2181,48 @@ fn verify_batched_stage7<T>(
     program: &'static Stage7VerifierProgramPlan,
     driver: &'static Stage7SumcheckDriverPlan,
     proof: &Stage7SumcheckOutput<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage7SumcheckOutput<Fr>, VerifyStage7Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage7Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs)
+            bolt_verifier_runtime::evaluate_relation_output_batch(
+                driver,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                &[],
+                store,
+                evals,
+                point,
+                batching_coeffs,
+                |_, _, _| Ok::<_, VerifyStage7Error>(bolt_verifier_runtime::RelationOutputInputs::empty()),
+            )
         },
         |store, verified| observe_stage7_sumcheck_output(program, store, verified),
         |driver, error| VerifyStage7Error::Sumcheck { driver, error },
@@ -2145,7 +2231,7 @@ where
 
 fn observe_stage7_sumcheck_output<F: Field>(
     program: &'static Stage7VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage7SumcheckOutput<F>,
 ) -> Result<(), VerifyStage7Error> {
     store.observe_sumcheck_output(
@@ -2154,15 +2240,12 @@ fn observe_stage7_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage7_trace_rounds(program)?, "stage7.bytecode_read_raf.point")?,
-                "stage7_booleanity" => {}
-                "instruction_read_raf" => point = normalize_instruction_read_raf_point(&point, "stage7.instruction_read_raf.point")?,
-                _ => {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
                     return Err(VerifyStage7Error::InvalidProof {
                         driver: output.driver,
-                        reason: "unsupported point order",
+                        reason: "unsupported relation-local point order",
                     });
                 }
             }
@@ -2176,8 +2259,7 @@ fn observe_stage7_sumcheck_output<F: Field>(
         |symbol| VerifyStage7Error::MissingValue { symbol },
     )?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage7Error::InvalidInputLength {
             input,
             expected,
@@ -2185,7 +2267,7 @@ fn observe_stage7_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage7Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -2193,127 +2275,6 @@ fn observe_stage7_sumcheck_output<F: Field>(
         |symbol| VerifyStage7Error::MissingValue { symbol },
     )
 }
-
-fn expected_batched_output_claim(
-    program: &'static Stage7VerifierProgramPlan,
-    driver: &'static Stage7SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage7NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage7Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage7Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage7Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let relation = claim.relation.unwrap_or("<missing>");
-        let value = match relation {
-            "jolt.stage7.hamming_weight_claim_reduction" => {
-                expected_hamming_weight_claim_reduction(program, driver, store, evals, local_point)?
-            }
-            _ => return Err(VerifyStage7Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_hamming_weight_claim_reduction(
-    program: &'static Stage7VerifierProgramPlan,
-    driver: &'static Stage7SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage7NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage7Error> {
-    let rho_rev = reverse_slice(local_point);
-    let booleanity_point = super::common::store_point(store, "stage7.input.stage6.booleanity.InstructionRa_0")?;
-    let r_addr_bool =
-        booleanity_point
-            .get(..local_point.len())
-            .ok_or(VerifyStage7Error::InvalidInputLength {
-                input: "stage7.input.stage6.booleanity.InstructionRa_0",
-                expected: local_point.len(),
-                actual: booleanity_point.len(),
-            })?;
-    let eq_bool = EqPolynomial::<Fr>::mle(&rho_rev, r_addr_bool);
-    let gamma = super::common::store_scalar(store, "stage7.hamming_weight_claim_reduction.gamma")?;
-    let mut gamma_power = Fr::from_u64(1);
-    let mut expected = Fr::from_u64(0);
-    let mut eval_plans = program
-        .evals
-        .iter()
-        .filter(|eval| eval.source == driver.symbol)
-        .collect::<Vec<_>>();
-    eval_plans.sort_by_key(|eval| eval.index);
-    for eval_plan in eval_plans {
-        let g_i = eval_by_name(evals, eval_plan.name)?;
-        let virt_point =
-            stage7_virtualization_point(store, eval_plan.oracle, local_point.len())?;
-        let eq_virt = EqPolynomial::<Fr>::mle(&rho_rev, virt_point);
-        expected += g_i * (gamma_power + gamma_power * gamma * eq_bool
-            + gamma_power * gamma.square() * eq_virt);
-        gamma_power *= gamma;
-        gamma_power *= gamma;
-        gamma_power *= gamma;
-    }
-    Ok(expected)
-}
-
-fn stage7_virtualization_point<'a>(
-    store: &'a super::common::ValueStore<Fr>,
-    oracle: &str,
-    log_k_chunk: usize,
-) -> Result<&'a [Fr], VerifyStage7Error> {
-    let symbol = if oracle.starts_with("InstructionRa_") {
-        format!("stage7.input.stage6.instruction_ra_virtual.{oracle}")
-    } else if oracle.starts_with("BytecodeRa_") {
-        format!("stage7.input.stage6.bytecode_read_raf.{oracle}")
-    } else if oracle.starts_with("RamRa_") {
-        format!("stage7.input.stage6.ram_ra_virtual.{oracle}")
-    } else {
-        return Err(VerifyStage7Error::MissingValue {
-            symbol: "stage7.hamming_weight_claim_reduction.oracle",
-        });
-    };
-    let point = store.try_point(&symbol).ok_or(VerifyStage7Error::MissingValue {
-        symbol: "stage7.hamming_weight_claim_reduction.virtualization_point",
-    })?;
-    point
-        .get(..log_k_chunk)
-        .ok_or(VerifyStage7Error::InvalidInputLength {
-            input: "stage7.hamming_weight_claim_reduction.virtualization_point",
-            expected: log_k_chunk,
-            actual: point.len(),
-        })
-}
-
-fn stage7_trace_rounds(
-    program: &'static Stage7VerifierProgramPlan,
-) -> Result<usize, VerifyStage7Error> {
-    program
-        .instance_results
-        .iter()
-        .find(|instance| instance.relation == "jolt.stage7.hamming_booleanity")
-        .map(|instance| instance.num_rounds)
-        .ok_or(VerifyStage7Error::MissingValue {
-            symbol: "stage7.hamming_booleanity.instance",
-        })
-}
 "#
             }
         }
@@ -2334,196 +2295,27 @@ fn stage7_trace_rounds(
     }
 }
 
-fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result<(), EmitError> {
-    if actual == expected {
-        Ok(())
-    } else {
-        Err(EmitError::new(format!(
-            "unsupported {kind} @{actual}; expected @{expected}"
-        )))
-    }
-}
-
-fn emit_str_array(name: &str, values: &[String]) -> String {
-    if values.is_empty() {
-        return format!("pub const {name}: &[&str] = &[];\n\n");
-    }
-    if let [value] = values {
-        return format!("pub const {name}: &[&str] = &[{}];\n\n", rust_str(value));
-    }
-    let entries = values
-        .iter()
-        .map(|value| format!("    {},", rust_str(value)))
-        .collect::<Vec<_>>()
-        .join("\n");
-    format!("pub const {name}: &[&str] = &[\n{entries}\n];\n\n")
-}
-
-fn emit_usize_array(name: &str, values: &[usize]) -> String {
-    let entries = values
-        .iter()
-        .map(|value| format!("    {value},"))
-        .collect::<Vec<_>>()
-        .join("\n");
-    format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n")
-}
-
-fn intern_str_array(
-    source: &mut String,
-    arrays: &mut Vec<(Vec<String>, String)>,
-    name_prefix: &str,
-    values: &[String],
-) -> String {
-    if let Some((_, name)) = arrays
+fn stage7_kernel_abi(relation: &str) -> Option<&'static str> {
+    STAGE7_KERNEL_ABIS
         .iter()
-        .find(|(existing, _)| existing.as_slice() == values)
-    {
-        return name.clone();
-    }
-    let name = format!("{name_prefix}_{}", arrays.len());
-    source.push_str(&emit_str_array(&name, values));
-    arrays.push((values.to_vec(), name.clone()));
-    name
-}
-
-fn rust_str(value: &str) -> String {
-    format!("{value:?}")
-}
-
-fn rust_option_str(value: Option<&str>) -> String {
-    value.map_or_else(
-        || "None".to_owned(),
-        |value| format!("Some({})", rust_str(value)),
-    )
-}
-
-fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Result<(), EmitError> {
-    if expected == actual {
-        Ok(())
-    } else {
-        Err(EmitError::new(format!(
-            "{kind} @{symbol} count mismatch: expected {expected}, got {actual}"
-        )))
-    }
+        .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi))
 }
 
-fn symbols<'a>(values: impl Iterator<Item = &'a String>) -> BTreeSet<String> {
-    values.cloned().collect()
-}
-
-fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(string_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "string"))
-}
-
-fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
-    operation
-        .attribute(attr)
-        .ok()
-        .and_then(symbol_attribute_value)
-        .ok_or_else(|| attr_error(operation, attr, "symbol"))
-}
-
-fn symbol_array_attr(
-    operation: OperationRef<'_, '_>,
-    attr: &str,
-) -> Result<Vec<String>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "symbol array"))?;
-    parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array"))
-}
-
-fn parse_symbol_array(attribute: &str) -> Option<Vec<String>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
-    }
-    inner
-        .split(',')
-        .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned))
-        .collect()
-}
-
-fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<usize, EmitError> {
-    operation
-        .attribute(attr)
-        .map(parse_integer_attr)
-        .ok()
-        .flatten()
-        .ok_or_else(|| attr_error(operation, attr, "integer"))
-}
-
-fn parse_integer_attr(attribute: Attribute<'_>) -> Option<usize> {
-    attribute
-        .to_string()
-        .split_whitespace()
-        .next()
-        .and_then(|value| value.parse().ok())
-}
-
-fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<Vec<usize>, EmitError> {
-    let attribute = operation
-        .attribute(attr)
-        .map(|attribute| attribute.to_string())
-        .ok()
-        .ok_or_else(|| attr_error(operation, attr, "integer array"))?;
-    parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array"))
-}
+#[cfg(test)]
+mod tests {
+    use super::{stage7_kernel_abi, STAGE7_KERNEL_ABIS};
 
-fn parse_int_array(attribute: &str) -> Option<Vec<usize>> {
-    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
-    if inner.is_empty() {
-        return Some(Vec::new());
+    #[test]
+    fn stage7_kernel_abi_contracts_cover_supported_relations() {
+        assert_eq!(STAGE7_KERNEL_ABIS.len(), 2);
+        assert_eq!(
+            stage7_kernel_abi("jolt.stage7.hamming_weight_claim_reduction"),
+            Some("jolt_stage7_hamming_weight_claim_reduction")
+        );
+        assert_eq!(
+            stage7_kernel_abi("jolt.stage7.batched"),
+            Some("jolt_stage7_batched")
+        );
+        assert_eq!(stage7_kernel_abi("jolt.stage6.batched"), None);
     }
-    inner
-        .split(',')
-        .map(|item| item.trim().parse().ok())
-        .collect()
-}
-
-fn operand_symbols(
-    operation: OperationRef<'_, '_>,
-    start_index: usize,
-) -> Result<Vec<String>, EmitError> {
-    (start_index..operation.operand_count())
-        .map(|index| operand_symbol(operation, index))
-        .collect()
-}
-
-fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result<String, EmitError> {
-    let operand = operation.operand(index).map_err(|_| {
-        EmitError::new(format!(
-            "{} requires operand {index}",
-            operation_name(operation)
-        ))
-    })?;
-    let owner = OperationResult::try_from(operand).map_err(|_| {
-        EmitError::new(format!(
-            "{} operand {index} must be an op result",
-            operation_name(operation)
-        ))
-    })?;
-    string_attr(owner.owner(), "sym_name")
-}
-
-fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError {
-    EmitError::new(format!(
-        "{} attr `{attr}` is not a {expected}",
-        operation_name(operation)
-    ))
-}
-
-fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String {
-    operation
-        .name()
-        .as_string_ref()
-        .as_str()
-        .unwrap_or("<invalid-operation-name>")
-        .to_owned()
 }
diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs
index 9914b4b4cf..ba761a3030 100644
--- a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs
+++ b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs
@@ -237,6 +237,19 @@ impl Stage8CpuProgram {
                 "stage8 opening batch ordered claims do not match SSA operands",
             ));
         }
+        let batch_symbols = self
+            .opening_batches
+            .iter()
+            .map(|batch| batch.symbol.as_str())
+            .collect::<BTreeSet<_>>();
+        for proof in &self.pcs_proofs {
+            if !batch_symbols.contains(proof.batch.as_str()) {
+                return Err(EmitError::new(format!(
+                    "stage8 PCS proof `{}` references missing opening batch `{}`",
+                    proof.symbol, proof.batch
+                )));
+            }
+        }
         if !self
             .opening_inputs
             .iter()
@@ -278,38 +291,59 @@ impl Stage8CpuProgram {
     fn emit_source(&self) -> Result<String, EmitError> {
         let mut source = String::new();
         source.push_str("#![allow(clippy::too_many_lines)]\n\n");
+        match self.role {
+            Role::Verifier => source.push_str(
+                "pub use bolt_verifier_runtime::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, StageParams as Stage8Params, TypedPlanSymbol};\n\n\
+                 #[derive(Clone, Copy, Debug, PartialEq, Eq)]\n\
+                 pub enum Stage8SourceStage {\n    Stage6,\n    Stage7,\n}\n\n\
+                 impl Stage8SourceStage {\n    pub fn as_str(self) -> &'static str {\n        match self {\n            Self::Stage6 => \"stage6\",\n            Self::Stage7 => \"stage7\",\n        }\n    }\n}\n\n\
+                 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n\
+                 pub enum Stage8OpeningInputTag {}\n\
+                 pub type Stage8OpeningInputSymbol = TypedPlanSymbol<Stage8OpeningInputTag>;\n\
+                 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n\
+                 pub enum Stage8OpeningClaimTag {}\n\
+                 pub type Stage8OpeningClaimSymbol = TypedPlanSymbol<Stage8OpeningClaimTag>;\n\
+                 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n\
+                 pub enum Stage8OpeningBatchTag {}\n\
+                 pub type Stage8OpeningBatchSymbol = TypedPlanSymbol<Stage8OpeningBatchTag>;\n\
+                 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n\
+                 pub enum Stage8SourceClaimTag {}\n\
+                 pub type Stage8SourceClaim = TypedPlanSymbol<Stage8SourceClaimTag>;\n\n",
+            ),
+            Role::Prover => source.push_str(prover_local_plan_types()),
+        }
         source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n");
         source.push_str(
-            "pub struct Stage8Params {\n    pub field: &'static str,\n    pub pcs: &'static str,\n    pub transcript: &'static str,\n}\n\n",
-        );
-        source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n");
-        source.push_str(
-            "pub struct Stage8OpeningInputPlan {\n    pub symbol: &'static str,\n    pub source_stage: &'static str,\n    pub source_claim: &'static str,\n    pub oracle: &'static str,\n    pub domain: &'static str,\n    pub point_arity: usize,\n    pub claim_kind: &'static str,\n}\n\n",
+            "pub struct Stage8OpeningInputPlan {\n    pub symbol: Stage8OpeningInputSymbol,\n    pub source_stage: Stage8SourceStage,\n    pub source_claim: Stage8SourceClaim,\n    pub oracle: &'static str,\n    pub domain: &'static str,\n    pub point_arity: usize,\n    pub claim_kind: Stage8ClaimKind,\n}\n\n",
         );
         source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n");
         source.push_str(
-            "pub struct Stage8OpeningClaimPlan {\n    pub symbol: &'static str,\n    pub oracle: &'static str,\n    pub family: &'static str,\n    pub domain: &'static str,\n    pub point_arity: usize,\n    pub point_source: &'static str,\n    pub eval_source: &'static str,\n    pub source_stage: &'static str,\n    pub source_claim: &'static str,\n}\n\n",
+            "pub struct Stage8OpeningClaimPlan {\n    pub symbol: Stage8OpeningClaimSymbol,\n    pub oracle: &'static str,\n    pub family: &'static str,\n    pub domain: &'static str,\n    pub point_arity: usize,\n    pub point_source: Stage8OpeningInputSymbol,\n    pub eval_source: Stage8OpeningInputSymbol,\n    pub source_stage: Stage8SourceStage,\n    pub source_claim: Stage8SourceClaim,\n}\n\n",
         );
         source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n");
         source.push_str(
-            "pub struct Stage8OpeningBatchPlan {\n    pub symbol: &'static str,\n    pub proof_slot: &'static str,\n    pub policy: &'static str,\n    pub count: usize,\n    pub ordered_claims: &'static [&'static str],\n}\n\n",
+            "pub struct Stage8OpeningBatchPlan {\n    pub symbol: Stage8OpeningBatchSymbol,\n    pub proof_slot: &'static str,\n    pub policy: &'static str,\n    pub count: usize,\n    pub ordered_claims: &'static [Stage8OpeningClaimPlan],\n}\n\n",
         );
+        if self.role == Role::Prover {
+            source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n");
+            source.push_str("pub enum Stage8PcsProofMode {\n    Open,\n    Verify,\n}\n\n");
+        }
         source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n");
         source.push_str(
-            "pub struct Stage8PcsProofPlan {\n    pub symbol: &'static str,\n    pub mode: &'static str,\n    pub pcs: &'static str,\n    pub proof_slot: &'static str,\n    pub transcript_label: &'static str,\n    pub batch: &'static str,\n}\n\n",
+            "pub struct Stage8PcsProofPlan {\n    pub symbol: &'static str,\n    pub mode: Stage8PcsProofMode,\n    pub pcs: &'static str,\n    pub proof_slot: &'static str,\n    pub transcript_label: &'static str,\n    pub batch: Stage8OpeningBatchSymbol,\n}\n\n",
         );
         source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n");
         source.push_str(
             "pub struct Stage8EvaluationProgramPlan {\n    pub role: &'static str,\n    pub function: &'static str,\n    pub params: Stage8Params,\n    pub evaluation_point_source: Stage8OpeningInputPlan,\n    pub opening_inputs: &'static [Stage8OpeningInputPlan],\n    pub opening_claims: &'static [Stage8OpeningClaimPlan],\n    pub opening_batch: Stage8OpeningBatchPlan,\n    pub pcs_proof: Stage8PcsProofPlan,\n}\n\n",
         );
+        source.push_str(stage8_plan_constructors());
+        source.push_str(stage8_evaluation_helpers());
 
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE8_PARAMS: Stage8Params = Stage8Params {{ field: {}, pcs: {}, transcript: {} }};\n\n",
-                rust_str(&self.params.field),
-                rust_str(&self.params.pcs),
-                rust_str(&self.params.transcript),
+                "pub const STAGE8_PARAMS: Stage8Params = {};\n\n",
+                params_literal(&self.params),
             ),
         );
         let point_source = self
@@ -325,33 +359,26 @@ impl Stage8CpuProgram {
             &mut source,
             format_args!(
                 "pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = {};\n\n",
-                opening_input_literal(point_source),
+                opening_input_literal(point_source)?,
             ),
         );
-        source.push_str("pub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[\n");
+        source.push_str(
+            "#[rustfmt::skip]\npub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[\n",
+        );
         for input in &self.opening_inputs {
             push_format(
                 &mut source,
-                format_args!("    {},\n", opening_input_literal(input)),
+                format_args!("    {},\n", opening_input_literal(input)?),
             );
         }
         source.push_str("];\n\n");
-        source.push_str("pub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[\n");
+        source.push_str(
+            "#[rustfmt::skip]\npub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[\n",
+        );
         for claim in &self.opening_claims {
             push_format(
                 &mut source,
-                format_args!(
-                    "    Stage8OpeningClaimPlan {{ symbol: {}, oracle: {}, family: {}, domain: {}, point_arity: {}, point_source: {}, eval_source: {}, source_stage: {}, source_claim: {} }},\n",
-                    rust_str(&claim.symbol),
-                    rust_str(&claim.oracle),
-                    rust_str(&claim.family),
-                    rust_str(&claim.domain),
-                    claim.point_arity,
-                    rust_str(&claim.point_source),
-                    rust_str(&claim.eval_source),
-                    rust_str(&claim.source_stage),
-                    rust_str(&claim.source_claim),
-                ),
+                format_args!("    {},\n", opening_claim_literal(claim)?),
             );
         }
         source.push_str("];\n\n");
@@ -359,37 +386,22 @@ impl Stage8CpuProgram {
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE8_OPENING_BATCH_ORDERED_CLAIMS: &[&str] = &{};\n\n",
-                rust_str_array(&batch.ordered_claims),
-            ),
-        );
-        push_format(
-            &mut source,
-            format_args!(
-                "pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan {{ symbol: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: STAGE8_OPENING_BATCH_ORDERED_CLAIMS }};\n\n",
-                rust_str(&batch.symbol),
-                rust_str(&batch.proof_slot),
-                rust_str(&batch.policy),
-                batch.count,
+                "#[rustfmt::skip]\npub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = {};\n\n",
+                opening_batch_literal(batch),
             ),
         );
         let proof = &self.pcs_proofs[0];
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan {{ symbol: {}, mode: {}, pcs: {}, proof_slot: {}, transcript_label: {}, batch: {} }};\n\n",
-                rust_str(&proof.symbol),
-                rust_str(&proof.mode),
-                rust_str(&proof.pcs),
-                rust_str(&proof.proof_slot),
-                rust_str(&proof.transcript_label),
-                rust_str(&proof.batch),
+                "#[rustfmt::skip]\npub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = {};\n\n",
+                pcs_proof_literal(proof)?,
             ),
         );
         push_format(
             &mut source,
             format_args!(
-                "pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan {{\n    role: {},\n    function: {},\n    params: STAGE8_PARAMS,\n    evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE,\n    opening_inputs: STAGE8_OPENING_INPUTS,\n    opening_claims: STAGE8_OPENING_CLAIMS,\n    opening_batch: STAGE8_OPENING_BATCH,\n    pcs_proof: STAGE8_PCS_PROOF,\n}};\n",
+                "#[rustfmt::skip]\npub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan {{ role: {}, function: {}, params: STAGE8_PARAMS, evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE, opening_inputs: STAGE8_OPENING_INPUTS, opening_claims: STAGE8_OPENING_CLAIMS, opening_batch: STAGE8_OPENING_BATCH, pcs_proof: STAGE8_PCS_PROOF }};\n",
                 rust_str(self.role.as_str()),
                 rust_str(&self.function),
             ),
@@ -398,30 +410,405 @@ impl Stage8CpuProgram {
     }
 }
 
-fn opening_input_literal(input: &Stage8OpeningInputPlan) -> String {
+fn params_literal(params: &Stage8Params) -> String {
     format!(
-        "Stage8OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }}",
+        "Stage8Params {{ field: {}, pcs: {}, transcript: {} }}",
+        rust_str(&params.field),
+        rust_str(&params.pcs),
+        rust_str(&params.transcript),
+    )
+}
+
+fn stage8_plan_constructors() -> &'static str {
+    r"const fn stage8_opening_input(
+    symbol: &'static str,
+    source_stage: Stage8SourceStage,
+    source_claim: &'static str,
+    oracle: &'static str,
+    domain: &'static str,
+    point_arity: usize,
+    claim_kind: Stage8ClaimKind,
+) -> Stage8OpeningInputPlan {
+    Stage8OpeningInputPlan {
+        symbol: Stage8OpeningInputSymbol::new(symbol),
+        source_stage,
+        source_claim: Stage8SourceClaim::new(source_claim),
+        oracle,
+        domain,
+        point_arity,
+        claim_kind,
+    }
+}
+
+const fn stage8_opening_claim(
+    symbol: &'static str,
+    oracle: &'static str,
+    family: &'static str,
+    domain: &'static str,
+    point_arity: usize,
+    input_symbol: &'static str,
+    source: (Stage8SourceStage, &'static str),
+) -> Stage8OpeningClaimPlan {
+    Stage8OpeningClaimPlan {
+        symbol: Stage8OpeningClaimSymbol::new(symbol),
+        oracle,
+        family,
+        domain,
+        point_arity,
+        point_source: Stage8OpeningInputSymbol::new(input_symbol),
+        eval_source: Stage8OpeningInputSymbol::new(input_symbol),
+        source_stage: source.0,
+        source_claim: Stage8SourceClaim::new(source.1),
+    }
+}
+
+"
+}
+
+fn prover_local_plan_types() -> &'static str {
+    r#"#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage8Params {
+    pub field: &'static str,
+    pub pcs: &'static str,
+    pub transcript: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage8ClaimKind {
+    Committed,
+    Virtual,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage8SourceStage {
+    Stage6,
+    Stage7,
+}
+
+impl Stage8SourceStage {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Stage6 => "stage6",
+            Self::Stage7 => "stage7",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Stage8OpeningInputSymbol(&'static str);
+
+impl Stage8OpeningInputSymbol {
+    pub const fn new(symbol: &'static str) -> Self {
+        Self(symbol)
+    }
+
+    pub fn as_str(self) -> &'static str {
+        self.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Stage8OpeningClaimSymbol(&'static str);
+
+impl Stage8OpeningClaimSymbol {
+    pub const fn new(symbol: &'static str) -> Self {
+        Self(symbol)
+    }
+
+    pub fn as_str(self) -> &'static str {
+        self.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Stage8OpeningBatchSymbol(&'static str);
+
+impl Stage8OpeningBatchSymbol {
+    pub const fn new(symbol: &'static str) -> Self {
+        Self(symbol)
+    }
+
+    pub fn as_str(self) -> &'static str {
+        self.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Stage8SourceClaim(&'static str);
+
+impl Stage8SourceClaim {
+    pub const fn new(symbol: &'static str) -> Self {
+        Self(symbol)
+    }
+
+    pub fn as_str(self) -> &'static str {
+        self.0
+    }
+}
+
+"#
+}
+
+fn stage8_evaluation_helpers() -> &'static str {
+    r#"#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage8EvaluationClaim<F> {
+    pub oracle: &'static str,
+    pub source_stage: Stage8SourceStage,
+    pub value: F,
+}
+
+pub fn reverse_point<F: Copy>(point: &[F]) -> Vec<F> {
+    point.iter().rev().copied().collect()
+}
+
+pub fn append_rlc_claims<F, T>(transcript: &mut T, claims: &[Stage8EvaluationClaim<F>])
+where
+    F: jolt_field::Field + jolt_transcript::AppendToTranscript,
+    T: jolt_transcript::Transcript<Challenge = F>,
+{
+    transcript.append(&jolt_transcript::LabelWithCount(
+        b"rlc_claims",
+        claims.len() as u64,
+    ));
+    for claim in claims {
+        jolt_transcript::AppendToTranscript::append_to_transcript(&claim.value, transcript);
+    }
+}
+
+pub fn gamma_powers<F, T>(transcript: &mut T, count: usize) -> Vec<F>
+where
+    F: jolt_field::Field,
+    T: jolt_transcript::Transcript<Challenge = F>,
+{
+    let gamma = transcript.challenge();
+    let mut powers = Vec::with_capacity(count);
+    let mut power = F::from_u64(1);
+    for _ in 0..count {
+        powers.push(power);
+        power *= gamma;
+    }
+    powers
+}
+
+pub trait Stage8NamedEvalView<F> {
+    fn name(&self) -> &'static str;
+    fn value(&self) -> F;
+}
+
+pub trait Stage8SumcheckOutputView<F> {
+    type Eval: Stage8NamedEvalView<F>;
+
+    fn point(&self) -> &[F];
+    fn evals(&self) -> &[Self::Eval];
+}
+
+pub fn stage7_claim_values<F, O>(
+    program: &'static Stage8EvaluationProgramPlan,
+    outputs: &[O],
+) -> Option<(Vec<F>, std::collections::BTreeMap<Stage8SourceClaim, F>)>
+where
+    F: Copy,
+    O: Stage8SumcheckOutputView<F>,
+{
+    let stage7_plans = program
+        .opening_claims
+        .iter()
+        .filter(|plan| plan.source_stage == Stage8SourceStage::Stage7)
+        .collect::<Vec<_>>();
+    for output in outputs {
+        let mut values = std::collections::BTreeMap::new();
+        for plan in &stage7_plans {
+            if let Some(eval) = output
+                .evals()
+                .iter()
+                .find(|eval| eval.name() == plan.source_claim.as_str())
+            {
+                let _ = values.insert(plan.source_claim, eval.value());
+            }
+        }
+        if values.len() == stage7_plans.len() {
+            return Some((output.point().to_vec(), values));
+        }
+    }
+    None
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage8EvaluationClaimError {
+    pub stage: &'static str,
+    pub eval: &'static str,
+}
+
+pub fn evaluation_claims<F, O>(
+    program: &'static Stage8EvaluationProgramPlan,
+    stage6_outputs: &[O],
+    stage7_values: &std::collections::BTreeMap<Stage8SourceClaim, F>,
+    lagrange_factor: F,
+) -> Result<Vec<Stage8EvaluationClaim<F>>, Stage8EvaluationClaimError>
+where
+    F: Copy + std::ops::Mul<Output = F>,
+    O: Stage8SumcheckOutputView<F>,
+{
+    let mut claims = Vec::with_capacity(program.opening_claims.len());
+    for plan in program.opening_claims {
+        let value = match plan.source_stage {
+            Stage8SourceStage::Stage6 => {
+                stage_eval(stage6_outputs, plan.source_stage.as_str(), plan.source_claim)?
+                    * lagrange_factor
+            }
+            Stage8SourceStage::Stage7 => *stage7_values.get(&plan.source_claim).ok_or(
+                Stage8EvaluationClaimError {
+                    stage: plan.source_stage.as_str(),
+                    eval: plan.source_claim.as_str(),
+                },
+            )?,
+        };
+        claims.push(Stage8EvaluationClaim {
+            oracle: plan.oracle,
+            source_stage: plan.source_stage,
+            value,
+        });
+    }
+    Ok(claims)
+}
+
+fn stage_eval<F, O>(
+    outputs: &[O],
+    stage: &'static str,
+    eval_name: Stage8SourceClaim,
+) -> Result<F, Stage8EvaluationClaimError>
+where
+    F: Copy,
+    O: Stage8SumcheckOutputView<F>,
+{
+    for output in outputs {
+        let eval = output
+            .evals()
+            .iter()
+            .find(|eval| eval.name() == eval_name.as_str());
+        if let Some(eval) = eval { return Ok(eval.value()); }
+    }
+    Err(Stage8EvaluationClaimError {
+        stage,
+        eval: eval_name.as_str(),
+    })
+}
+
+pub trait Stage8OpeningInputView<F> {
+    fn symbol(&self) -> &'static str;
+    fn point(&self) -> &[F];
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage8EvaluationOpeningPointError {
+    MissingStage7EvaluationPoint,
+    InvalidPointLength {
+        artifact: &'static str,
+        expected: usize,
+        actual: usize,
+    },
+}
+
+pub fn stage7_evaluation_opening_point<F, I>(
+    program: &'static Stage8EvaluationProgramPlan,
+    address_point: &[F],
+    stage7_openings: &[I],
+) -> Result<(Vec<F>, usize), Stage8EvaluationOpeningPointError>
+where
+    F: Copy,
+    I: Stage8OpeningInputView<F>,
+{
+    let cycle_source_symbol = program.evaluation_point_source.source_claim;
+    let cycle_source = stage7_openings
+        .iter()
+        .find(|input| input.symbol() == cycle_source_symbol.as_str())
+        .ok_or(Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint)?;
+    let cycle_source_point = cycle_source.point();
+    if cycle_source_point.len() < address_point.len() {
+        return Err(Stage8EvaluationOpeningPointError::InvalidPointLength {
+            artifact: cycle_source_symbol.as_str(),
+            expected: address_point.len(),
+            actual: cycle_source_point.len(),
+        });
+    }
+    let cycle_len = cycle_source_point.len() - address_point.len();
+    let mut point = Vec::with_capacity(cycle_source_point.len());
+    point.extend_from_slice(address_point);
+    point.extend_from_slice(&cycle_source_point[address_point.len()..]);
+    Ok((point, cycle_len))
+}
+
+"#
+}
+
+fn opening_input_literal(input: &Stage8OpeningInputPlan) -> Result<String, EmitError> {
+    Ok(format!(
+        "stage8_opening_input({}, {}, {}, {}, {}, {}, {})",
         rust_str(&input.symbol),
-        rust_str(&input.source_stage),
+        source_stage_expr(&input.source_stage)?,
         rust_str(&input.source_claim),
         rust_str(&input.oracle),
         rust_str(&input.domain),
         input.point_arity,
-        rust_str(&input.claim_kind),
+        super::plan_tokens::claim_kind_expr("Stage8", &input.claim_kind)?,
+    ))
+}
+
+fn opening_claim_literal(claim: &Stage8OpeningClaimPlan) -> Result<String, EmitError> {
+    Ok(format!(
+        "stage8_opening_claim({}, {}, {}, {}, {}, {}, ({}, {}))",
+        rust_str(&claim.symbol),
+        rust_str(&claim.oracle),
+        rust_str(&claim.family),
+        rust_str(&claim.domain),
+        claim.point_arity,
+        rust_str(&claim.point_source),
+        source_stage_expr(&claim.source_stage)?,
+        rust_str(&claim.source_claim),
+    ))
+}
+
+fn source_stage_expr(source_stage: &str) -> Result<String, EmitError> {
+    let variant = match source_stage {
+        "stage6" => "Stage6",
+        "stage7" => "Stage7",
+        _ => {
+            return Err(EmitError::new(format!(
+                "unsupported Stage 8 source stage `{source_stage}`"
+            )))
+        }
+    };
+    Ok(format!("Stage8SourceStage::{variant}"))
+}
+
+fn symbol_expr(type_name: &str, symbol: &str) -> String {
+    format!("{type_name}::new({})", rust_str(symbol))
+}
+
+fn opening_batch_literal(batch: &Stage8OpeningBatchPlan) -> String {
+    format!(
+        "Stage8OpeningBatchPlan {{ symbol: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: STAGE8_OPENING_CLAIMS }}",
+        symbol_expr("Stage8OpeningBatchSymbol", &batch.symbol),
+        rust_str(&batch.proof_slot),
+        rust_str(&batch.policy),
+        batch.count,
     )
 }
 
-fn rust_str(value: &str) -> String {
-    format!("{value:?}")
+fn pcs_proof_literal(proof: &Stage8PcsProofPlan) -> Result<String, EmitError> {
+    Ok(format!(
+        "Stage8PcsProofPlan {{ symbol: {}, mode: {}, pcs: {}, proof_slot: {}, transcript_label: {}, batch: {} }}",
+        rust_str(&proof.symbol),
+        super::plan_tokens::pcs_proof_mode_expr("Stage8", &proof.mode)?,
+        rust_str(&proof.pcs),
+        rust_str(&proof.proof_slot),
+        rust_str(&proof.transcript_label),
+        symbol_expr("Stage8OpeningBatchSymbol", &proof.batch),
+    ))
 }
 
-fn rust_str_array(values: &[String]) -> String {
-    let values = values
-        .iter()
-        .map(|value| rust_str(value))
-        .collect::<Vec<_>>()
-        .join(", ");
-    format!("[{values}]")
+fn rust_str(value: &str) -> String {
+    format!("{value:?}")
 }
 
 fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<String, EmitError> {
@@ -514,3 +901,111 @@ fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String {
         .unwrap_or("<invalid-operation-name>")
         .to_owned()
 }
+
+#[cfg(test)]
+#[expect(
+    clippy::expect_used,
+    reason = "tests assert exact Stage 8 validation failures"
+)]
+mod tests {
+    use super::*;
+
+    fn valid_verifier_program() -> Stage8CpuProgram {
+        Stage8CpuProgram {
+            role: Role::Verifier,
+            params: Stage8Params {
+                field: "Fr".to_owned(),
+                pcs: "Dory".to_owned(),
+                transcript: "Blake2b".to_owned(),
+            },
+            function: "jolt.stage8".to_owned(),
+            opening_inputs: vec![
+                Stage8OpeningInputPlan {
+                    symbol: EVALUATION_POINT_SOURCE_SYMBOL.to_owned(),
+                    source_stage: "stage7".to_owned(),
+                    source_claim: "stage7.input.stage6.booleanity.InstructionRa_0".to_owned(),
+                    oracle: "InstructionRa_0".to_owned(),
+                    domain: "hamming_weight".to_owned(),
+                    point_arity: 4,
+                    claim_kind: "virtual".to_owned(),
+                },
+                Stage8OpeningInputPlan {
+                    symbol: "stage8.input.stage6.RamInc".to_owned(),
+                    source_stage: "stage6".to_owned(),
+                    source_claim: "stage6.inc_claim_reduction.eval.RamInc".to_owned(),
+                    oracle: "RamInc".to_owned(),
+                    domain: "ram".to_owned(),
+                    point_arity: 4,
+                    claim_kind: "committed".to_owned(),
+                },
+            ],
+            opening_claims: vec![Stage8OpeningClaimPlan {
+                symbol: "stage8.evaluation.opening.RamInc".to_owned(),
+                oracle: "RamInc".to_owned(),
+                family: "commitment".to_owned(),
+                domain: "ram".to_owned(),
+                point_arity: 4,
+                point_source: "stage8.input.stage6.RamInc".to_owned(),
+                eval_source: "stage8.input.stage6.RamInc".to_owned(),
+                source_stage: "stage6".to_owned(),
+                source_claim: "stage6.inc_claim_reduction.eval.RamInc".to_owned(),
+            }],
+            opening_batches: vec![Stage8OpeningBatchPlan {
+                symbol: "stage8.evaluation.openings".to_owned(),
+                proof_slot: "@stage8.evaluation".to_owned(),
+                policy: "jolt_stage8_joint_rlc".to_owned(),
+                count: 1,
+                ordered_claims: vec!["stage8.evaluation.opening.RamInc".to_owned()],
+                claim_operands: vec!["stage8.evaluation.opening.RamInc".to_owned()],
+            }],
+            pcs_proofs: vec![Stage8PcsProofPlan {
+                symbol: "stage8.evaluation.proof".to_owned(),
+                mode: "verify".to_owned(),
+                pcs: "dory".to_owned(),
+                proof_slot: "@stage8.evaluation".to_owned(),
+                transcript_label: "rlc_claims".to_owned(),
+                batch: "stage8.evaluation.openings".to_owned(),
+            }],
+        }
+    }
+
+    #[test]
+    fn stage8_validation_rejects_missing_evaluation_point_source() {
+        let mut program = valid_verifier_program();
+        program
+            .opening_inputs
+            .retain(|input| input.symbol != EVALUATION_POINT_SOURCE_SYMBOL);
+
+        let error = program
+            .verify_supported_target()
+            .expect_err("missing Stage 8 evaluation point source is rejected");
+
+        assert!(
+            error.to_string().contains(
+                "stage8 program missing `stage8.evaluation.point_source` opening-point source"
+            ),
+            "{error}"
+        );
+    }
+
+    #[test]
+    fn stage8_validation_rejects_split_point_and_eval_sources() {
+        let mut program = valid_verifier_program();
+        program
+            .opening_claims
+            .first_mut()
+            .expect("fixture has an opening claim")
+            .eval_source = EVALUATION_POINT_SOURCE_SYMBOL.to_owned();
+
+        let error = program
+            .verify_supported_target()
+            .expect_err("split Stage 8 point/eval source is rejected");
+
+        assert!(
+            error.to_string().contains(
+                "stage8 claim `stage8.evaluation.opening.RamInc` must take point and eval from the same opening input"
+            ),
+            "{error}"
+        );
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs
index 91da996a0e..2fe67f7774 100644
--- a/crates/bolt/src/protocols/jolt/mod.rs
+++ b/crates/bolt/src/protocols/jolt/mod.rs
@@ -1,9 +1,23 @@
 pub mod artifacts;
+pub(crate) mod cpu_attrs;
 pub mod emit;
 pub mod oracles;
 pub mod params;
 pub mod phases;
+pub(crate) mod rust_target_plan;
+pub(crate) mod stage5_instruction_read_raf_plan;
+pub(crate) mod stage6_bytecode_read_raf_plan;
 pub mod validate;
+pub(crate) mod verifier_eval_families;
+pub(crate) mod verifier_local_scalars;
+pub(crate) mod verifier_opening_rows;
+pub(crate) mod verifier_plan;
+pub(crate) mod verifier_point_rows;
+pub(crate) mod verifier_program_rows;
+pub(crate) mod verifier_relation_outputs;
+pub(crate) mod verifier_sumcheck_rows;
+pub(crate) mod verifier_value_rows;
+pub(crate) mod verifier_values;
 
 pub use artifacts::{
     assemble_jolt_generated_crates, assemble_jolt_workspace_generated_crates, jolt_artifact_config,
diff --git a/crates/bolt/src/protocols/jolt/phases/commitment.rs b/crates/bolt/src/protocols/jolt/phases/commitment.rs
index 10327884cd..9deb69df0a 100644
--- a/crates/bolt/src/protocols/jolt/phases/commitment.rs
+++ b/crates/bolt/src/protocols/jolt/phases/commitment.rs
@@ -894,6 +894,16 @@ pub fn lower_compute_to_cpu<'c>(
                 )?;
                 insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
             }
+            "compute.sumcheck_eval_family" => {
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(op, &["source", "oracle_family", "count", "evals"])?;
+                context.append_op_with_owned_attrs(
+                    &cpu,
+                    "cpu.sumcheck_eval_family",
+                    Some(&symbol),
+                    &attrs,
+                )?;
+            }
             "compute.sumcheck_instance_result" => {
                 let operands = lowered_operands(op, &value_map)?;
                 let symbol = string_attr(op, "sym_name")?;
@@ -922,6 +932,117 @@ pub fn lower_compute_to_cpu<'c>(
                 insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
                 insert_result_mapping(&mut value_map, op, operation, 1, 1)?;
             }
+            "compute.structured_polynomial_eval" => {
+                let operands = lowered_operands(op, &value_map)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "polynomial",
+                        "x_point_segment",
+                        "x_point_length",
+                        "x_point_order",
+                        "y_point_segment",
+                        "y_point_length",
+                        "y_point_order",
+                    ],
+                )?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &cpu,
+                    "cpu.structured_polynomial_eval",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!cpu.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "compute.sumcheck_output_eval_family" => {
+                let operands = lowered_operands(op, &value_map)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "power_stride",
+                        "value_term_offsets",
+                        "shared_term_offsets",
+                        "item_term_offsets",
+                        "evals",
+                        "shared_terms",
+                        "item_terms",
+                    ],
+                )?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &cpu,
+                    "cpu.sumcheck_output_eval_family",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!cpu.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "compute.sumcheck_output_product_family" => {
+                let operands = lowered_operands(op, &value_map)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "gamma",
+                        "term_gamma_power_offsets",
+                        "term_eval_counts",
+                        "term_factor_counts",
+                        "evals",
+                        "factors",
+                    ],
+                )?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &cpu,
+                    "cpu.sumcheck_output_product_family",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!cpu.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "compute.sumcheck_output_function_family" => {
+                let operands = lowered_operands(op, &value_map)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "gamma",
+                        "term_gamma_power_offsets",
+                        "term_functions",
+                        "term_factor_counts",
+                        "evals",
+                        "factors",
+                    ],
+                )?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &cpu,
+                    "cpu.sumcheck_output_function_family",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!cpu.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "compute.sumcheck_output_claim" => {
+                let operands = lowered_operands(op, &value_map)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?;
+                let _operation = context.append_typed_op_with_owned_attrs(
+                    &cpu,
+                    "cpu.sumcheck_output_claim",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &[],
+                )?;
+            }
             "compute.opening_claim" => {
                 let operands = lowered_operands(op, &value_map)?;
                 let symbol = string_attr(op, "sym_name")?;
diff --git a/crates/bolt/src/protocols/jolt/phases/field_formula.rs b/crates/bolt/src/protocols/jolt/phases/field_formula.rs
new file mode 100644
index 0000000000..cc3a59e59c
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/phases/field_formula.rs
@@ -0,0 +1,127 @@
+use std::collections::BTreeMap;
+
+use melior::ir::Value;
+
+use crate::ir::{BoltModule, Protocol};
+use crate::mlir::{MeliorContext, MlirError};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum FieldOp {
+    Add,
+    Sub,
+    Mul,
+}
+
+impl FieldOp {
+    fn op_name(self) -> &'static str {
+        match self {
+            Self::Add => "field.add",
+            Self::Sub => "field.sub",
+            Self::Mul => "field.mul",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct FieldFormulaStep {
+    pub(crate) symbol: &'static str,
+    op: FieldOp,
+    lhs: &'static str,
+    rhs: &'static str,
+}
+
+impl FieldFormulaStep {
+    pub(crate) const fn add(symbol: &'static str, lhs: &'static str, rhs: &'static str) -> Self {
+        Self {
+            symbol,
+            op: FieldOp::Add,
+            lhs,
+            rhs,
+        }
+    }
+
+    pub(crate) const fn sub(symbol: &'static str, lhs: &'static str, rhs: &'static str) -> Self {
+        Self {
+            symbol,
+            op: FieldOp::Sub,
+            lhs,
+            rhs,
+        }
+    }
+
+    pub(crate) const fn mul(symbol: &'static str, lhs: &'static str, rhs: &'static str) -> Self {
+        Self {
+            symbol,
+            op: FieldOp::Mul,
+            lhs,
+            rhs,
+        }
+    }
+}
+
+pub(crate) struct FieldFormulaBuilder<'c, 'a> {
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    values: BTreeMap<&'static str, Value<'c, 'a>>,
+}
+
+impl<'c, 'a> FieldFormulaBuilder<'c, 'a> {
+    pub(crate) fn new(context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>) -> Self {
+        Self {
+            context,
+            module,
+            values: BTreeMap::new(),
+        }
+    }
+
+    pub(crate) fn bind(&mut self, symbol: &'static str, value: Value<'c, 'a>) {
+        let _ = self.values.insert(symbol, value);
+    }
+
+    pub(crate) fn bind_all(&mut self, values: &[(&'static str, Value<'c, 'a>)]) {
+        for (symbol, value) in values {
+            self.bind(symbol, *value);
+        }
+    }
+
+    pub(crate) fn append_all(&mut self, formulas: &[FieldFormulaStep]) -> Result<(), MlirError> {
+        for formula in formulas {
+            let _ = self.append(*formula)?;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn value(&self, symbol: &'static str) -> Result<Value<'c, 'a>, MlirError> {
+        self.values
+            .get(symbol)
+            .copied()
+            .ok_or_else(|| MlirError::Schema {
+                message: format!("field formula value @{symbol} is missing"),
+            })
+    }
+
+    fn append(&mut self, formula: FieldFormulaStep) -> Result<Value<'c, 'a>, MlirError> {
+        let lhs = self.value(formula.lhs)?;
+        let rhs = self.value(formula.rhs)?;
+        let op = self.context.append_typed_op(
+            self.module,
+            formula.op.op_name(),
+            Some(formula.symbol),
+            &[],
+            &[lhs, rhs],
+            &["!field.scalar"],
+        )?;
+        let value: Value<'c, 'a> = op
+            .result(0)
+            .map_err(|_| MlirError::Schema {
+                message: format!(
+                    "{} @{} did not produce a field value",
+                    formula.op.op_name(),
+                    formula.symbol
+                ),
+            })?
+            .into();
+        self.bind(formula.symbol, value);
+        Ok(value)
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/phases/lowering.rs b/crates/bolt/src/protocols/jolt/phases/lowering.rs
index ed50ed20db..6740720543 100644
--- a/crates/bolt/src/protocols/jolt/phases/lowering.rs
+++ b/crates/bolt/src/protocols/jolt/phases/lowering.rs
@@ -401,6 +401,16 @@ pub(super) fn lower_party_to_compute<'c>(
                 )?;
                 insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
             }
+            "piop.sumcheck_eval_family" => {
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(op, &["source", "oracle_family", "count", "evals"])?;
+                context.append_op_with_owned_attrs(
+                    &compute,
+                    "compute.sumcheck_eval_family",
+                    Some(&symbol),
+                    &attrs,
+                )?;
+            }
             "piop.sumcheck_instance_result" => {
                 let operands = lowered_operands(op, &value_map, 0)?;
                 let symbol = string_attr(op, "sym_name")?;
@@ -429,6 +439,117 @@ pub(super) fn lower_party_to_compute<'c>(
                 insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
                 insert_result_mapping(&mut value_map, op, operation, 1, 1)?;
             }
+            "piop.structured_polynomial_eval" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "polynomial",
+                        "x_point_segment",
+                        "x_point_length",
+                        "x_point_order",
+                        "y_point_segment",
+                        "y_point_length",
+                        "y_point_order",
+                    ],
+                )?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &compute,
+                    "compute.structured_polynomial_eval",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!compute.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "piop.sumcheck_output_eval_family" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "power_stride",
+                        "value_term_offsets",
+                        "shared_term_offsets",
+                        "item_term_offsets",
+                        "evals",
+                        "shared_terms",
+                        "item_terms",
+                    ],
+                )?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &compute,
+                    "compute.sumcheck_output_eval_family",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!compute.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "piop.sumcheck_output_product_family" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "gamma",
+                        "term_gamma_power_offsets",
+                        "term_eval_counts",
+                        "term_factor_counts",
+                        "evals",
+                        "factors",
+                    ],
+                )?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &compute,
+                    "compute.sumcheck_output_product_family",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!compute.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "piop.sumcheck_output_function_family" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "gamma",
+                        "term_gamma_power_offsets",
+                        "term_functions",
+                        "term_factor_counts",
+                        "evals",
+                        "factors",
+                    ],
+                )?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &compute,
+                    "compute.sumcheck_output_function_family",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!compute.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "piop.sumcheck_output_claim" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?;
+                let _operation = context.append_typed_op_with_owned_attrs(
+                    &compute,
+                    "compute.sumcheck_output_claim",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &[],
+                )?;
+            }
             "piop.opening_claim" => {
                 let operands = lowered_operands(op, &value_map, 0)?;
                 let symbol = string_attr(op, "sym_name")?;
diff --git a/crates/bolt/src/protocols/jolt/phases/mod.rs b/crates/bolt/src/protocols/jolt/phases/mod.rs
index 19f9646db3..dfc56da7e3 100644
--- a/crates/bolt/src/protocols/jolt/phases/mod.rs
+++ b/crates/bolt/src/protocols/jolt/phases/mod.rs
@@ -1,4 +1,6 @@
+mod field_formula;
 mod lowering;
+mod sumcheck_output;
 
 pub mod commitment;
 pub mod stage1;
diff --git a/crates/bolt/src/protocols/jolt/phases/stage1.rs b/crates/bolt/src/protocols/jolt/phases/stage1.rs
index 7501e62768..01e57d0a50 100644
--- a/crates/bolt/src/protocols/jolt/phases/stage1.rs
+++ b/crates/bolt/src/protocols/jolt/phases/stage1.rs
@@ -821,6 +821,16 @@ pub fn resolve_compute_kernels<'c>(
                 )?;
                 insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
             }
+            "compute.sumcheck_eval_family" => {
+                let attrs = copy_attrs(op, &["source", "oracle_family", "count", "evals"])?;
+                let symbol = string_attr(op, "sym_name")?;
+                context.append_op_with_owned_attrs(
+                    &kernelized,
+                    "compute.sumcheck_eval_family",
+                    Some(&symbol),
+                    &attrs,
+                )?;
+            }
             "compute.sumcheck_instance_result" => {
                 let operands = lowered_operands(op, &value_map, 0)?;
                 let attrs = copy_attrs(
@@ -849,6 +859,117 @@ pub fn resolve_compute_kernels<'c>(
                 insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
                 insert_result_mapping(&mut value_map, op, operation, 1, 1)?;
             }
+            "compute.structured_polynomial_eval" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "polynomial",
+                        "x_point_segment",
+                        "x_point_length",
+                        "x_point_order",
+                        "y_point_segment",
+                        "y_point_length",
+                        "y_point_order",
+                    ],
+                )?;
+                let symbol = string_attr(op, "sym_name")?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &kernelized,
+                    "compute.structured_polynomial_eval",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!compute.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "compute.sumcheck_output_eval_family" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "power_stride",
+                        "value_term_offsets",
+                        "shared_term_offsets",
+                        "item_term_offsets",
+                        "evals",
+                        "shared_terms",
+                        "item_terms",
+                    ],
+                )?;
+                let symbol = string_attr(op, "sym_name")?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &kernelized,
+                    "compute.sumcheck_output_eval_family",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!compute.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "compute.sumcheck_output_product_family" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "gamma",
+                        "term_gamma_power_offsets",
+                        "term_eval_counts",
+                        "term_factor_counts",
+                        "evals",
+                        "factors",
+                    ],
+                )?;
+                let symbol = string_attr(op, "sym_name")?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &kernelized,
+                    "compute.sumcheck_output_product_family",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!compute.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "compute.sumcheck_output_function_family" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "gamma",
+                        "term_gamma_power_offsets",
+                        "term_functions",
+                        "term_factor_counts",
+                        "evals",
+                        "factors",
+                    ],
+                )?;
+                let symbol = string_attr(op, "sym_name")?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &kernelized,
+                    "compute.sumcheck_output_function_family",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!compute.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "compute.sumcheck_output_claim" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?;
+                let symbol = string_attr(op, "sym_name")?;
+                let _operation = context.append_typed_op_with_owned_attrs(
+                    &kernelized,
+                    "compute.sumcheck_output_claim",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &[],
+                )?;
+            }
             "compute.opening_claim" => {
                 let operands = lowered_operands(op, &value_map, 0)?;
                 let attrs = copy_attrs(op, &["oracle", "domain", "point_arity", "claim_kind"])?;
diff --git a/crates/bolt/src/protocols/jolt/phases/stage3.rs b/crates/bolt/src/protocols/jolt/phases/stage3.rs
index b0e3c1513d..c8eda21692 100644
--- a/crates/bolt/src/protocols/jolt/phases/stage3.rs
+++ b/crates/bolt/src/protocols/jolt/phases/stage3.rs
@@ -14,10 +14,15 @@ use crate::schema::{
 
 use super::super::oracles;
 use super::super::params::JoltProtocolParams;
+use super::field_formula::{FieldFormulaBuilder, FieldFormulaStep};
 use super::lowering::{
     copy_attrs, field_lowering_attrs as field_compute_attrs, string_attr,
     transcript_squeeze_compute_result_types, transcript_squeeze_protocol_result_type,
 };
+use super::sumcheck_output::{
+    append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec,
+    StructuredPolynomialPointSpec, StructuredPolynomialSpec,
+};
 
 const SPARTAN_SHIFT_DEGREE: usize = 2;
 const INSTRUCTION_INPUT_DEGREE: usize = 3;
@@ -49,6 +54,140 @@ const STAGE3_INSTRUCTION_INPUT_OUTPUTS: [&str; 8] = [
 ];
 const STAGE3_REGISTER_INPUTS: [&str; 3] = ["RdWriteValue", "Rs1Value", "Rs2Value"];
 
+const STAGE3_SHIFT_OUTPUT_FORMULAS: [FieldFormulaStep; 11] = [
+    FieldFormulaStep::mul(
+        "stage3.spartan_shift.output.term.PC",
+        "stage3.spartan_shift.gamma",
+        "stage3.spartan_shift.eval.PC",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.spartan_shift.output.term.OpFlagVirtualInstruction",
+        "stage3.spartan_shift.gamma2",
+        "stage3.spartan_shift.eval.OpFlagVirtualInstruction",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence",
+        "stage3.spartan_shift.gamma3",
+        "stage3.spartan_shift.eval.OpFlagIsFirstInSequence",
+    ),
+    FieldFormulaStep::sub(
+        "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop",
+        "stage3.field.one",
+        "stage3.spartan_shift.eval.InstructionFlagIsNoop",
+    ),
+    FieldFormulaStep::add(
+        "stage3.spartan_shift.output.partial.PC",
+        "stage3.spartan_shift.eval.UnexpandedPC",
+        "stage3.spartan_shift.output.term.PC",
+    ),
+    FieldFormulaStep::add(
+        "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction",
+        "stage3.spartan_shift.output.partial.PC",
+        "stage3.spartan_shift.output.term.OpFlagVirtualInstruction",
+    ),
+    FieldFormulaStep::add(
+        "stage3.spartan_shift.output.weighted_outer",
+        "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction",
+        "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.spartan_shift.output.outer",
+        "stage3.spartan_shift.output.eq.NextPC",
+        "stage3.spartan_shift.output.weighted_outer",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.spartan_shift.output.noop_product",
+        "stage3.spartan_shift.output.eq.NextIsNoop",
+        "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.spartan_shift.output.noop_term",
+        "stage3.spartan_shift.gamma4",
+        "stage3.spartan_shift.output.noop_product",
+    ),
+    FieldFormulaStep::add(
+        "stage3.spartan_shift.output.claim_expr",
+        "stage3.spartan_shift.output.outer",
+        "stage3.spartan_shift.output.noop_term",
+    ),
+];
+
+const STAGE3_INSTRUCTION_OUTPUT_FORMULAS: [FieldFormulaStep; 9] = [
+    FieldFormulaStep::mul(
+        "stage3.instruction_input.output.left.term.Rs1Value",
+        "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value",
+        "stage3.instruction_input.eval.Rs1Value",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.instruction_input.output.left.term.PC",
+        "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC",
+        "stage3.instruction_input.eval.UnexpandedPC",
+    ),
+    FieldFormulaStep::add(
+        "stage3.instruction_input.output.left",
+        "stage3.instruction_input.output.left.term.Rs1Value",
+        "stage3.instruction_input.output.left.term.PC",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.instruction_input.output.right.term.Rs2Value",
+        "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value",
+        "stage3.instruction_input.eval.Rs2Value",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.instruction_input.output.right.term.Imm",
+        "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm",
+        "stage3.instruction_input.eval.Imm",
+    ),
+    FieldFormulaStep::add(
+        "stage3.instruction_input.output.right",
+        "stage3.instruction_input.output.right.term.Rs2Value",
+        "stage3.instruction_input.output.right.term.Imm",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.instruction_input.output.left_weighted",
+        "stage3.instruction_input.gamma",
+        "stage3.instruction_input.output.left",
+    ),
+    FieldFormulaStep::add(
+        "stage3.instruction_input.output.weighted_inputs",
+        "stage3.instruction_input.output.right",
+        "stage3.instruction_input.output.left_weighted",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.instruction_input.output.claim_expr",
+        "stage3.instruction_input.output.eq.LeftInstructionInput",
+        "stage3.instruction_input.output.weighted_inputs",
+    ),
+];
+
+const STAGE3_REGISTERS_OUTPUT_FORMULAS: [FieldFormulaStep; 5] = [
+    FieldFormulaStep::mul(
+        "stage3.registers.output.term.Rs1Value",
+        "stage3.registers.gamma",
+        "stage3.registers_claim_reduction.eval.Rs1Value",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.registers.output.term.Rs2Value",
+        "stage3.registers.gamma2",
+        "stage3.registers_claim_reduction.eval.Rs2Value",
+    ),
+    FieldFormulaStep::add(
+        "stage3.registers.output.partial.RdWriteValueRs1Value",
+        "stage3.registers_claim_reduction.eval.RdWriteValue",
+        "stage3.registers.output.term.Rs1Value",
+    ),
+    FieldFormulaStep::add(
+        "stage3.registers.output.weighted_register_values",
+        "stage3.registers.output.partial.RdWriteValueRs1Value",
+        "stage3.registers.output.term.Rs2Value",
+    ),
+    FieldFormulaStep::mul(
+        "stage3.registers.output.claim_expr",
+        "stage3.registers.output.eq.RdWriteValue",
+        "stage3.registers.output.weighted_register_values",
+    ),
+];
+
 pub fn build_stage3_protocol<'c>(
     context: &'c MeliorContext,
     params: &JoltProtocolParams,
@@ -473,6 +612,44 @@ pub fn lower_stage3_to_compute<'c>(
                 insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
                 insert_result_mapping(&mut value_map, op, operation, 1, 1)?;
             }
+            "piop.structured_polynomial_eval" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(
+                    op,
+                    &[
+                        "polynomial",
+                        "x_point_segment",
+                        "x_point_length",
+                        "x_point_order",
+                        "y_point_segment",
+                        "y_point_length",
+                        "y_point_order",
+                    ],
+                )?;
+                let operation = context.append_typed_op_with_owned_attrs(
+                    &compute,
+                    "compute.structured_polynomial_eval",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &["!compute.field_value"],
+                )?;
+                insert_result_mapping(&mut value_map, op, operation, 0, 0)?;
+            }
+            "piop.sumcheck_output_claim" => {
+                let operands = lowered_operands(op, &value_map, 0)?;
+                let symbol = string_attr(op, "sym_name")?;
+                let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?;
+                let _operation = context.append_typed_op_with_owned_attrs(
+                    &compute,
+                    "compute.sumcheck_output_claim",
+                    Some(&symbol),
+                    &attrs,
+                    &operands,
+                    &[],
+                )?;
+            }
             "piop.opening_claim" => {
                 let operands = lowered_operands(op, &value_map, 0)?;
                 let symbol = string_attr(op, "sym_name")?;
@@ -805,6 +982,7 @@ fn append_stage_input<'c, 'a>(
         &["!poly.point", "!field.scalar", "!piop.opening_claim_type"],
     )?;
     Ok(Stage3OpeningInput {
+        point: result(op, 0, "piop.opening_input")?,
         eval: result(op, 1, "piop.opening_input")?,
         claim: result(op, 2, "piop.opening_input")?,
     })
@@ -1250,71 +1428,281 @@ fn append_stage3_batched_sumcheck<'c, 'a>(
         point,
         result_value,
     )?;
-    append_stage3_output_openings(
+    let output_evals = append_stage3_output_openings(
         context,
         module,
-        &[
-            InstanceOutput {
-                prefix: "stage3.spartan_shift",
-                instance: shift,
-                outputs: &STAGE3_SHIFT_OUTPUTS,
-                degree_offset: 0,
-            },
-            InstanceOutput {
-                prefix: "stage3.instruction_input",
-                instance: instruction,
-                outputs: &STAGE3_INSTRUCTION_INPUT_OUTPUTS,
-                degree_offset: STAGE3_SHIFT_OUTPUTS.len(),
-            },
-            InstanceOutput {
-                prefix: "stage3.registers_claim_reduction",
-                instance: registers,
-                outputs: &STAGE3_REGISTER_INPUTS,
-                degree_offset: STAGE3_SHIFT_OUTPUTS.len() + STAGE3_INSTRUCTION_INPUT_OUTPUTS.len(),
-            },
-        ],
+        Stage3Instances {
+            shift,
+            instruction,
+            registers,
+        },
         params.log_t,
     )?;
+    append_stage3_output_claims(
+        context,
+        module,
+        Stage3OutputClaimInputs {
+            openings: inputs,
+            output_evals: &output_evals,
+            instances: Stage3Instances {
+                shift,
+                instruction,
+                registers,
+            },
+            shift_gamma: spec.shift_gamma,
+            shift_gamma2,
+            shift_gamma3,
+            shift_gamma4,
+            field_one: one,
+            instruction_gamma: spec.instruction_gamma,
+            registers_gamma: spec.registers_gamma,
+            registers_gamma2,
+        },
+    )?;
     Ok(state)
 }
 
 fn append_stage3_output_openings<'c, 'a>(
     context: &'c MeliorContext,
     module: &'a BoltModule<'c, Protocol>,
-    outputs: &[InstanceOutput<'c, 'a, '_>],
+    instances: Stage3Instances<'c, 'a>,
     point_arity: usize,
-) -> Result<(), MlirError> {
+) -> Result<Stage3OutputEvals<'c, 'a>, MlirError> {
     let mut claims = Vec::new();
     let mut claim_symbols = Vec::new();
 
-    for output in outputs {
-        for (index, &oracle) in output.outputs.iter().enumerate() {
-            let symbol = format!("{}.opening.{oracle}", output.prefix);
-            let eval = append_sumcheck_eval(
-                context,
-                module,
-                &format!("{}.eval.{oracle}", output.prefix),
-                "stage3.sumcheck",
-                oracle,
-                output.degree_offset + index,
-                output.instance.1,
-            )?;
-            claim_symbols.push(symbol.clone());
-            claims.push(append_opening_claim(
-                context,
-                module,
-                output.instance.0,
-                eval,
-                OpeningClaimSpec {
-                    symbol: &symbol,
-                    oracle,
-                    domain: "jolt.trace_domain",
-                    point_arity,
-                    claim_kind: "virtual",
-                },
-            )?);
-        }
-    }
+    let shift = Stage3ShiftOutputEvals {
+        unexpanded_pc: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.spartan_shift",
+                oracle: "UnexpandedPC",
+                index: 0,
+                degree_offset: 0,
+                instance: instances.shift,
+                point_arity,
+            },
+        )?,
+        pc: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.spartan_shift",
+                oracle: "PC",
+                index: 1,
+                degree_offset: 0,
+                instance: instances.shift,
+                point_arity,
+            },
+        )?,
+        op_flag_virtual_instruction: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.spartan_shift",
+                oracle: "OpFlagVirtualInstruction",
+                index: 2,
+                degree_offset: 0,
+                instance: instances.shift,
+                point_arity,
+            },
+        )?,
+        op_flag_is_first_in_sequence: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.spartan_shift",
+                oracle: "OpFlagIsFirstInSequence",
+                index: 3,
+                degree_offset: 0,
+                instance: instances.shift,
+                point_arity,
+            },
+        )?,
+        instruction_flag_is_noop: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.spartan_shift",
+                oracle: "InstructionFlagIsNoop",
+                index: 4,
+                degree_offset: 0,
+                instance: instances.shift,
+                point_arity,
+            },
+        )?,
+    };
+
+    let instruction = Stage3InstructionInputOutputEvals {
+        left_operand_is_rs1_value: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.instruction_input",
+                oracle: "InstructionFlagLeftOperandIsRs1Value",
+                index: 0,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len(),
+                instance: instances.instruction,
+                point_arity,
+            },
+        )?,
+        rs1_value: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.instruction_input",
+                oracle: "Rs1Value",
+                index: 1,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len(),
+                instance: instances.instruction,
+                point_arity,
+            },
+        )?,
+        left_operand_is_pc: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.instruction_input",
+                oracle: "InstructionFlagLeftOperandIsPC",
+                index: 2,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len(),
+                instance: instances.instruction,
+                point_arity,
+            },
+        )?,
+        unexpanded_pc: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.instruction_input",
+                oracle: "UnexpandedPC",
+                index: 3,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len(),
+                instance: instances.instruction,
+                point_arity,
+            },
+        )?,
+        right_operand_is_rs2_value: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.instruction_input",
+                oracle: "InstructionFlagRightOperandIsRs2Value",
+                index: 4,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len(),
+                instance: instances.instruction,
+                point_arity,
+            },
+        )?,
+        rs2_value: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.instruction_input",
+                oracle: "Rs2Value",
+                index: 5,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len(),
+                instance: instances.instruction,
+                point_arity,
+            },
+        )?,
+        right_operand_is_imm: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.instruction_input",
+                oracle: "InstructionFlagRightOperandIsImm",
+                index: 6,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len(),
+                instance: instances.instruction,
+                point_arity,
+            },
+        )?,
+        imm: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.instruction_input",
+                oracle: "Imm",
+                index: 7,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len(),
+                instance: instances.instruction,
+                point_arity,
+            },
+        )?,
+    };
+
+    let registers = Stage3RegistersOutputEvals {
+        rd_write: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.registers_claim_reduction",
+                oracle: "RdWriteValue",
+                index: 0,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len() + STAGE3_INSTRUCTION_INPUT_OUTPUTS.len(),
+                instance: instances.registers,
+                point_arity,
+            },
+        )?,
+        rs1: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.registers_claim_reduction",
+                oracle: "Rs1Value",
+                index: 1,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len() + STAGE3_INSTRUCTION_INPUT_OUTPUTS.len(),
+                instance: instances.registers,
+                point_arity,
+            },
+        )?,
+        rs2: append_output_eval_claim(
+            context,
+            module,
+            &mut claims,
+            &mut claim_symbols,
+            OutputEvalClaimSpec {
+                prefix: "stage3.registers_claim_reduction",
+                oracle: "Rs2Value",
+                index: 2,
+                degree_offset: STAGE3_SHIFT_OUTPUTS.len() + STAGE3_INSTRUCTION_INPUT_OUTPUTS.len(),
+                instance: instances.registers,
+                point_arity,
+            },
+        )?,
+    };
 
     let claim_names = claim_symbols.iter().map(String::as_str).collect::<Vec<_>>();
     let _batch = context.append_typed_op(
@@ -1331,7 +1719,244 @@ fn append_stage3_output_openings<'c, 'a>(
         &claims,
         &["!piop.opening_batch_type"],
     )?;
-    Ok(())
+    Ok(Stage3OutputEvals {
+        shift,
+        instruction,
+        registers,
+    })
+}
+
+fn append_output_eval_claim<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    claims: &mut Vec<Value<'c, 'a>>,
+    claim_symbols: &mut Vec<String>,
+    spec: OutputEvalClaimSpec<'c, 'a, '_>,
+) -> Result<Value<'c, 'a>, MlirError> {
+    let symbol = format!("{}.opening.{}", spec.prefix, spec.oracle);
+    let eval = append_sumcheck_eval(
+        context,
+        module,
+        &format!("{}.eval.{}", spec.prefix, spec.oracle),
+        "stage3.sumcheck",
+        spec.oracle,
+        spec.degree_offset + spec.index,
+        spec.instance.1,
+    )?;
+    claim_symbols.push(symbol.clone());
+    claims.push(append_opening_claim(
+        context,
+        module,
+        spec.instance.0,
+        eval,
+        OpeningClaimSpec {
+            symbol: &symbol,
+            oracle: spec.oracle,
+            domain: "jolt.trace_domain",
+            point_arity: spec.point_arity,
+            claim_kind: "virtual",
+        },
+    )?);
+    Ok(eval)
+}
+
+fn append_stage3_output_claims<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    spec: Stage3OutputClaimInputs<'c, 'a, '_>,
+) -> Result<(), MlirError> {
+    let shift_eq_next_pc = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage3.spartan_shift.output.eq.NextPC",
+            polynomial: "eq_plus_one",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::full("as_is"),
+        },
+        spec.instances.shift.0,
+        spec.openings.next_pc.point,
+    )?;
+    let shift_eq_next_is_noop = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage3.spartan_shift.output.eq.NextIsNoop",
+            polynomial: "eq_plus_one",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::full("as_is"),
+        },
+        spec.instances.shift.0,
+        spec.openings.product_next_is_noop.point,
+    )?;
+    let mut formula = FieldFormulaBuilder::new(context, module);
+    formula.bind_all(&[
+        ("stage3.spartan_shift.gamma", spec.shift_gamma),
+        ("stage3.spartan_shift.gamma2", spec.shift_gamma2),
+        ("stage3.spartan_shift.gamma3", spec.shift_gamma3),
+        ("stage3.spartan_shift.gamma4", spec.shift_gamma4),
+        ("stage3.field.one", spec.field_one),
+        (
+            "stage3.spartan_shift.eval.UnexpandedPC",
+            spec.output_evals.shift.unexpanded_pc,
+        ),
+        ("stage3.spartan_shift.eval.PC", spec.output_evals.shift.pc),
+        (
+            "stage3.spartan_shift.eval.OpFlagVirtualInstruction",
+            spec.output_evals.shift.op_flag_virtual_instruction,
+        ),
+        (
+            "stage3.spartan_shift.eval.OpFlagIsFirstInSequence",
+            spec.output_evals.shift.op_flag_is_first_in_sequence,
+        ),
+        (
+            "stage3.spartan_shift.eval.InstructionFlagIsNoop",
+            spec.output_evals.shift.instruction_flag_is_noop,
+        ),
+        ("stage3.spartan_shift.output.eq.NextPC", shift_eq_next_pc),
+        (
+            "stage3.spartan_shift.output.eq.NextIsNoop",
+            shift_eq_next_is_noop,
+        ),
+    ]);
+    formula.append_all(&STAGE3_SHIFT_OUTPUT_FORMULAS)?;
+    let shift_claim = formula.value("stage3.spartan_shift.output.claim_expr")?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage3.spartan_shift.output.claim",
+            stage: "stage3",
+            relation: "jolt.stage3.spartan_shift",
+        },
+        shift_claim,
+        &[
+            ("stage3.spartan_shift.output.eq.NextPC", shift_eq_next_pc),
+            (
+                "stage3.spartan_shift.output.eq.NextIsNoop",
+                shift_eq_next_is_noop,
+            ),
+        ],
+    )?;
+
+    let instruction_eq_left = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage3.instruction_input.output.eq.LeftInstructionInput",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::full("as_is"),
+        },
+        spec.instances.instruction.0,
+        spec.openings.product_left_instruction_input.point,
+    )?;
+    let mut formula = FieldFormulaBuilder::new(context, module);
+    formula.bind_all(&[
+        ("stage3.instruction_input.gamma", spec.instruction_gamma),
+        (
+            "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value",
+            spec.output_evals.instruction.left_operand_is_rs1_value,
+        ),
+        (
+            "stage3.instruction_input.eval.Rs1Value",
+            spec.output_evals.instruction.rs1_value,
+        ),
+        (
+            "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC",
+            spec.output_evals.instruction.left_operand_is_pc,
+        ),
+        (
+            "stage3.instruction_input.eval.UnexpandedPC",
+            spec.output_evals.instruction.unexpanded_pc,
+        ),
+        (
+            "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value",
+            spec.output_evals.instruction.right_operand_is_rs2_value,
+        ),
+        (
+            "stage3.instruction_input.eval.Rs2Value",
+            spec.output_evals.instruction.rs2_value,
+        ),
+        (
+            "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm",
+            spec.output_evals.instruction.right_operand_is_imm,
+        ),
+        (
+            "stage3.instruction_input.eval.Imm",
+            spec.output_evals.instruction.imm,
+        ),
+        (
+            "stage3.instruction_input.output.eq.LeftInstructionInput",
+            instruction_eq_left,
+        ),
+    ]);
+    formula.append_all(&STAGE3_INSTRUCTION_OUTPUT_FORMULAS)?;
+    let instruction_claim = formula.value("stage3.instruction_input.output.claim_expr")?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage3.instruction_input.output.claim",
+            stage: "stage3",
+            relation: "jolt.stage3.instruction_input",
+        },
+        instruction_claim,
+        &[(
+            "stage3.instruction_input.output.eq.LeftInstructionInput",
+            instruction_eq_left,
+        )],
+    )?;
+
+    let registers_eq_rd_write = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage3.registers.output.eq.RdWriteValue",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::full("as_is"),
+        },
+        spec.instances.registers.0,
+        spec.openings.rd_write_value.point,
+    )?;
+    let mut formula = FieldFormulaBuilder::new(context, module);
+    formula.bind_all(&[
+        ("stage3.registers.gamma", spec.registers_gamma),
+        ("stage3.registers.gamma2", spec.registers_gamma2),
+        (
+            "stage3.registers_claim_reduction.eval.RdWriteValue",
+            spec.output_evals.registers.rd_write,
+        ),
+        (
+            "stage3.registers_claim_reduction.eval.Rs1Value",
+            spec.output_evals.registers.rs1,
+        ),
+        (
+            "stage3.registers_claim_reduction.eval.Rs2Value",
+            spec.output_evals.registers.rs2,
+        ),
+        (
+            "stage3.registers.output.eq.RdWriteValue",
+            registers_eq_rd_write,
+        ),
+    ]);
+    formula.append_all(&STAGE3_REGISTERS_OUTPUT_FORMULAS)?;
+    let registers_claim = formula.value("stage3.registers.output.claim_expr")?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage3.registers.output.claim",
+            stage: "stage3",
+            relation: "jolt.stage3.registers_claim_reduction",
+        },
+        registers_claim,
+        &[(
+            "stage3.registers.output.eq.RdWriteValue",
+            registers_eq_rd_write,
+        )],
+    )
 }
 
 fn append_sumcheck_claim<'c, 'a>(
@@ -1655,6 +2280,7 @@ fn schema_error(message: impl Into<String>) -> MlirError {
 
 #[derive(Clone, Copy)]
 struct Stage3OpeningInput<'c, 'a> {
+    point: Value<'c, 'a>,
     eval: Value<'c, 'a>,
     claim: Value<'c, 'a>,
 }
@@ -1754,9 +2380,63 @@ struct OpeningClaimSpec<'a> {
     claim_kind: &'a str,
 }
 
-struct InstanceOutput<'c, 'a, 'b> {
+#[derive(Clone, Copy)]
+struct Stage3Instances<'c, 'a> {
+    shift: (Value<'c, 'a>, Value<'c, 'a>),
+    instruction: (Value<'c, 'a>, Value<'c, 'a>),
+    registers: (Value<'c, 'a>, Value<'c, 'a>),
+}
+
+struct OutputEvalClaimSpec<'c, 'a, 'b> {
     prefix: &'b str,
-    instance: (Value<'c, 'a>, Value<'c, 'a>),
-    outputs: &'b [&'b str],
+    oracle: &'b str,
+    index: usize,
     degree_offset: usize,
+    instance: (Value<'c, 'a>, Value<'c, 'a>),
+    point_arity: usize,
+}
+
+struct Stage3OutputEvals<'c, 'a> {
+    shift: Stage3ShiftOutputEvals<'c, 'a>,
+    instruction: Stage3InstructionInputOutputEvals<'c, 'a>,
+    registers: Stage3RegistersOutputEvals<'c, 'a>,
+}
+
+struct Stage3ShiftOutputEvals<'c, 'a> {
+    unexpanded_pc: Value<'c, 'a>,
+    pc: Value<'c, 'a>,
+    op_flag_virtual_instruction: Value<'c, 'a>,
+    op_flag_is_first_in_sequence: Value<'c, 'a>,
+    instruction_flag_is_noop: Value<'c, 'a>,
+}
+
+struct Stage3InstructionInputOutputEvals<'c, 'a> {
+    left_operand_is_rs1_value: Value<'c, 'a>,
+    rs1_value: Value<'c, 'a>,
+    left_operand_is_pc: Value<'c, 'a>,
+    unexpanded_pc: Value<'c, 'a>,
+    right_operand_is_rs2_value: Value<'c, 'a>,
+    rs2_value: Value<'c, 'a>,
+    right_operand_is_imm: Value<'c, 'a>,
+    imm: Value<'c, 'a>,
+}
+
+struct Stage3RegistersOutputEvals<'c, 'a> {
+    rd_write: Value<'c, 'a>,
+    rs1: Value<'c, 'a>,
+    rs2: Value<'c, 'a>,
+}
+
+struct Stage3OutputClaimInputs<'c, 'a, 'b> {
+    openings: &'b Stage3OpeningInputs<'c, 'a>,
+    output_evals: &'b Stage3OutputEvals<'c, 'a>,
+    instances: Stage3Instances<'c, 'a>,
+    shift_gamma: Value<'c, 'a>,
+    shift_gamma2: Value<'c, 'a>,
+    shift_gamma3: Value<'c, 'a>,
+    shift_gamma4: Value<'c, 'a>,
+    field_one: Value<'c, 'a>,
+    instruction_gamma: Value<'c, 'a>,
+    registers_gamma: Value<'c, 'a>,
+    registers_gamma2: Value<'c, 'a>,
 }
diff --git a/crates/bolt/src/protocols/jolt/phases/stage4.rs b/crates/bolt/src/protocols/jolt/phases/stage4.rs
index adf6bc080a..6fdc021be1 100644
--- a/crates/bolt/src/protocols/jolt/phases/stage4.rs
+++ b/crates/bolt/src/protocols/jolt/phases/stage4.rs
@@ -7,7 +7,12 @@ use crate::schema::{verify_protocol_schema, SchemaError};
 
 use super::super::oracles;
 use super::super::params::JoltProtocolParams;
+use super::field_formula::{FieldFormulaBuilder, FieldFormulaStep};
 use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type};
+use super::sumcheck_output::{
+    append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec,
+    StructuredPolynomialPointSpec, StructuredPolynomialSpec,
+};
 
 const REGISTERS_RW_DEGREE: usize = 3;
 const RAM_VAL_CHECK_DEGREE: usize = 3;
@@ -17,6 +22,72 @@ const STAGE4_REGISTER_INPUTS: [&str; 3] = ["RdWriteValue", "Rs1Value", "Rs2Value
 const STAGE4_REGISTER_OUTPUTS: [&str; 5] = ["RegistersVal", "Rs1Ra", "Rs2Ra", "RdWa", "RdInc"];
 const STAGE4_RAM_VAL_OUTPUTS: [&str; 2] = ["RamRa", "RamInc"];
 
+const STAGE4_REGISTERS_OUTPUT_FORMULAS: [FieldFormulaStep; 9] = [
+    FieldFormulaStep::add(
+        "stage4.registers_read_write.output.sum.RegistersValRdInc",
+        "stage4.registers_read_write.eval.RegistersVal",
+        "stage4.registers_read_write.eval.RdInc",
+    ),
+    FieldFormulaStep::mul(
+        "stage4.registers_read_write.output.term.RdWa",
+        "stage4.registers_read_write.eval.RdWa",
+        "stage4.registers_read_write.output.sum.RegistersValRdInc",
+    ),
+    FieldFormulaStep::mul(
+        "stage4.registers_read_write.output.term.Rs1Ra",
+        "stage4.registers_read_write.eval.Rs1Ra",
+        "stage4.registers_read_write.eval.RegistersVal",
+    ),
+    FieldFormulaStep::mul(
+        "stage4.registers_read_write.output.term.Rs2Ra",
+        "stage4.registers_read_write.eval.Rs2Ra",
+        "stage4.registers_read_write.eval.RegistersVal",
+    ),
+    FieldFormulaStep::mul(
+        "stage4.registers_read_write.output.weighted.Rs2Ra",
+        "stage4.registers_read_write.gamma",
+        "stage4.registers_read_write.output.term.Rs2Ra",
+    ),
+    FieldFormulaStep::add(
+        "stage4.registers_read_write.output.read_terms",
+        "stage4.registers_read_write.output.term.Rs1Ra",
+        "stage4.registers_read_write.output.weighted.Rs2Ra",
+    ),
+    FieldFormulaStep::mul(
+        "stage4.registers_read_write.output.weighted.read_terms",
+        "stage4.registers_read_write.gamma",
+        "stage4.registers_read_write.output.read_terms",
+    ),
+    FieldFormulaStep::add(
+        "stage4.registers_read_write.output.weighted_values",
+        "stage4.registers_read_write.output.term.RdWa",
+        "stage4.registers_read_write.output.weighted.read_terms",
+    ),
+    FieldFormulaStep::mul(
+        "stage4.registers_read_write.output.claim_expr",
+        "stage4.registers_read_write.output.eq.RdWriteValue",
+        "stage4.registers_read_write.output.weighted_values",
+    ),
+];
+
+const STAGE4_RAM_VAL_OUTPUT_FORMULAS: [FieldFormulaStep; 3] = [
+    FieldFormulaStep::add(
+        "stage4.ram_val_check.output.lt_plus_gamma",
+        "stage4.ram_val_check.output.lt.RamValCycle",
+        "stage4.ram_val_check.gamma",
+    ),
+    FieldFormulaStep::mul(
+        "stage4.ram_val_check.output.term.RamIncRamRa",
+        "stage4.ram_val_check.eval.RamInc",
+        "stage4.ram_val_check.eval.RamRa",
+    ),
+    FieldFormulaStep::mul(
+        "stage4.ram_val_check.output.claim_expr",
+        "stage4.ram_val_check.output.term.RamIncRamRa",
+        "stage4.ram_val_check.output.lt_plus_gamma",
+    ),
+];
+
 pub fn build_stage4_protocol<'c>(
     context: &'c MeliorContext,
     params: &JoltProtocolParams,
@@ -656,7 +727,18 @@ fn append_stage4_batched_sumcheck<'c, 'a>(
         point,
         result_value,
     )?;
-    append_stage4_output_openings(context, module, params, inputs, registers, ram_val_check)?;
+    append_stage4_output_openings(
+        context,
+        module,
+        params,
+        Stage4OutputOpeningsInputs {
+            openings: inputs,
+            registers,
+            ram_val_check,
+            registers_gamma: spec.registers_gamma,
+            ram_val_check_gamma: spec.ram_val_check_gamma,
+        },
+    )?;
     Ok(state)
 }
 
@@ -664,12 +746,14 @@ fn append_stage4_output_openings<'c, 'a>(
     context: &'c MeliorContext,
     module: &'a BoltModule<'c, Protocol>,
     params: &JoltProtocolParams,
-    inputs: &Stage4OpeningInputs<'c, 'a>,
-    registers: (Value<'c, 'a>, Value<'c, 'a>),
-    ram_val_check: (Value<'c, 'a>, Value<'c, 'a>),
+    spec: Stage4OutputOpeningsInputs<'c, 'a, '_>,
 ) -> Result<(), MlirError> {
+    let inputs = spec.openings;
+    let registers = spec.registers;
+    let ram_val_check = spec.ram_val_check;
     let mut claims = Vec::new();
     let mut claim_symbols = Vec::new();
+    let mut register_evals = Vec::new();
 
     for (index, &oracle) in ["RegistersVal", "Rs1Ra", "Rs2Ra", "RdWa"]
         .iter()
@@ -685,6 +769,7 @@ fn append_stage4_output_openings<'c, 'a>(
             index,
             registers.1,
         )?;
+        register_evals.push(eval);
         claim_symbols.push(symbol.clone());
         claims.push(append_opening_claim(
             context,
@@ -799,6 +884,32 @@ fn append_stage4_output_openings<'c, 'a>(
         },
     )?);
 
+    let [registers_val_eval, rs1_ra_eval, rs2_ra_eval, rd_wa_eval] = register_evals.as_slice()
+    else {
+        return Err(schema_error(format!(
+            "stage4 registers output eval count mismatch: expected 4, got {}",
+            register_evals.len()
+        )));
+    };
+    append_stage4_output_claims(
+        context,
+        module,
+        Stage4OutputClaimInputs {
+            openings: inputs,
+            registers,
+            ram_val_check,
+            registers_gamma: spec.registers_gamma,
+            ram_val_check_gamma: spec.ram_val_check_gamma,
+            registers_val_eval: *registers_val_eval,
+            rs1_ra_eval: *rs1_ra_eval,
+            rs2_ra_eval: *rs2_ra_eval,
+            rd_wa_eval: *rd_wa_eval,
+            rd_inc_eval,
+            ram_ra_eval,
+            ram_inc_eval,
+        },
+    )?;
+
     let claim_names = claim_symbols.iter().map(String::as_str).collect::<Vec<_>>();
     let _batch = context.append_typed_op(
         module,
@@ -817,6 +928,90 @@ fn append_stage4_output_openings<'c, 'a>(
     Ok(())
 }
 
+fn append_stage4_output_claims<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    spec: Stage4OutputClaimInputs<'c, 'a, '_>,
+) -> Result<(), MlirError> {
+    let registers_eq_trace = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage4.registers_read_write.output.eq.RdWriteValue",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::prefix("y_point", "reverse"),
+            y_point: StructuredPolynomialPointSpec::full("as_is"),
+        },
+        spec.registers.0,
+        spec.openings.rd_write_value.point,
+    )?;
+    let mut formula = FieldFormulaBuilder::new(context, module);
+    formula.bind_all(&[
+        ("stage4.registers_read_write.gamma", spec.registers_gamma),
+        (
+            "stage4.registers_read_write.eval.RegistersVal",
+            spec.registers_val_eval,
+        ),
+        ("stage4.registers_read_write.eval.Rs1Ra", spec.rs1_ra_eval),
+        ("stage4.registers_read_write.eval.Rs2Ra", spec.rs2_ra_eval),
+        ("stage4.registers_read_write.eval.RdWa", spec.rd_wa_eval),
+        ("stage4.registers_read_write.eval.RdInc", spec.rd_inc_eval),
+        (
+            "stage4.registers_read_write.output.eq.RdWriteValue",
+            registers_eq_trace,
+        ),
+    ]);
+    formula.append_all(&STAGE4_REGISTERS_OUTPUT_FORMULAS)?;
+    let registers_claim = formula.value("stage4.registers_read_write.output.claim_expr")?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage4.registers_read_write.output.claim",
+            stage: "stage4",
+            relation: "jolt.stage4.registers_read_write",
+        },
+        registers_claim,
+        &[(
+            "stage4.registers_read_write.output.eq.RdWriteValue",
+            registers_eq_trace,
+        )],
+    )?;
+
+    let ram_lt = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage4.ram_val_check.output.lt.RamValCycle",
+            polynomial: "lt",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"),
+        },
+        spec.ram_val_check.0,
+        spec.openings.ram_val.point,
+    )?;
+    let mut formula = FieldFormulaBuilder::new(context, module);
+    formula.bind_all(&[
+        ("stage4.ram_val_check.gamma", spec.ram_val_check_gamma),
+        ("stage4.ram_val_check.eval.RamRa", spec.ram_ra_eval),
+        ("stage4.ram_val_check.eval.RamInc", spec.ram_inc_eval),
+        ("stage4.ram_val_check.output.lt.RamValCycle", ram_lt),
+    ]);
+    formula.append_all(&STAGE4_RAM_VAL_OUTPUT_FORMULAS)?;
+    let ram_val_claim = formula.value("stage4.ram_val_check.output.claim_expr")?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage4.ram_val_check.output.claim",
+            stage: "stage4",
+            relation: "jolt.stage4.ram_val_check",
+        },
+        ram_val_claim,
+        &[("stage4.ram_val_check.output.lt.RamValCycle", ram_lt)],
+    )
+}
+
 fn append_opening_claim_equal<'c>(
     context: &'c MeliorContext,
     module: &BoltModule<'c, Protocol>,
@@ -1183,6 +1378,29 @@ struct Stage4BatchedSumcheckInputs<'c, 'a, 'b> {
     ram_val_check_gamma: Value<'c, 'a>,
 }
 
+struct Stage4OutputOpeningsInputs<'c, 'a, 'b> {
+    openings: &'b Stage4OpeningInputs<'c, 'a>,
+    registers: (Value<'c, 'a>, Value<'c, 'a>),
+    ram_val_check: (Value<'c, 'a>, Value<'c, 'a>),
+    registers_gamma: Value<'c, 'a>,
+    ram_val_check_gamma: Value<'c, 'a>,
+}
+
+struct Stage4OutputClaimInputs<'c, 'a, 'b> {
+    openings: &'b Stage4OpeningInputs<'c, 'a>,
+    registers: (Value<'c, 'a>, Value<'c, 'a>),
+    ram_val_check: (Value<'c, 'a>, Value<'c, 'a>),
+    registers_gamma: Value<'c, 'a>,
+    ram_val_check_gamma: Value<'c, 'a>,
+    registers_val_eval: Value<'c, 'a>,
+    rs1_ra_eval: Value<'c, 'a>,
+    rs2_ra_eval: Value<'c, 'a>,
+    rd_wa_eval: Value<'c, 'a>,
+    rd_inc_eval: Value<'c, 'a>,
+    ram_ra_eval: Value<'c, 'a>,
+    ram_inc_eval: Value<'c, 'a>,
+}
+
 struct SumcheckClaimSpec<'a> {
     symbol: &'a str,
     stage: &'a str,
diff --git a/crates/bolt/src/protocols/jolt/phases/stage5.rs b/crates/bolt/src/protocols/jolt/phases/stage5.rs
index 3a7b1171e8..fdd3a9b3a6 100644
--- a/crates/bolt/src/protocols/jolt/phases/stage5.rs
+++ b/crates/bolt/src/protocols/jolt/phases/stage5.rs
@@ -8,6 +8,10 @@ use crate::schema::{verify_protocol_schema, SchemaError};
 use super::super::oracles;
 use super::super::params::JoltProtocolParams;
 use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type};
+use super::sumcheck_output::{
+    append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec,
+    StructuredPolynomialPointSpec, StructuredPolynomialSpec,
+};
 
 const RAM_RA_CLAIM_REDUCTION_DEGREE: usize = 2;
 const REGISTERS_VAL_EVALUATION_DEGREE: usize = 3;
@@ -694,7 +698,25 @@ fn append_stage5_batched_sumcheck<'c, 'a>(
         point,
         result_value,
     )?;
-    append_stage5_output_openings(context, module, params, inputs, instruction, ram, registers)?;
+    let output_evals = append_stage5_output_openings(
+        context,
+        module,
+        params,
+        inputs,
+        instruction,
+        ram,
+        registers,
+    )?;
+    append_stage5_output_claims(
+        context,
+        module,
+        inputs,
+        ram,
+        registers,
+        &output_evals,
+        spec.ram_gamma,
+        ram_gamma2,
+    )?;
     Ok(state)
 }
 
@@ -706,7 +728,7 @@ fn append_stage5_output_openings<'c, 'a>(
     instruction: (Value<'c, 'a>, Value<'c, 'a>),
     ram: (Value<'c, 'a>, Value<'c, 'a>),
     registers: (Value<'c, 'a>, Value<'c, 'a>),
-) -> Result<(), MlirError> {
+) -> Result<Stage5OutputEvals<'c, 'a>, MlirError> {
     let mut claims = Vec::new();
     let mut claim_symbols = Vec::new();
 
@@ -719,10 +741,12 @@ fn append_stage5_output_openings<'c, 'a>(
         params.log_t,
         instruction.0,
     )?;
+    let mut table_flag_eval_symbols = Vec::with_capacity(params.lookup_table_count);
     for index in 0..params.lookup_table_count {
         let oracle = format!("LookupTableFlag_{index}");
         let symbol = format!("stage5.instruction_read_raf.opening.{oracle}");
         let eval_symbol = format!("stage5.instruction_read_raf.eval.{oracle}");
+        table_flag_eval_symbols.push(eval_symbol.clone());
         let eval = append_sumcheck_eval(
             context,
             module,
@@ -747,7 +771,16 @@ fn append_stage5_output_openings<'c, 'a>(
             },
         )?);
     }
+    append_sumcheck_eval_family(
+        context,
+        module,
+        "stage5.instruction_read_raf.eval.LookupTableFlag",
+        "stage5.sumcheck",
+        "LookupTableFlag",
+        &table_flag_eval_symbols,
+    )?;
 
+    let mut instruction_ra_eval_symbols = Vec::with_capacity(params.instruction_ra_virtual_d);
     for index in 0..params.instruction_ra_virtual_d {
         let oracle = format!("InstructionRa_{index}");
         let symbol = format!("stage5.instruction_read_raf.opening.{oracle}");
@@ -769,6 +802,7 @@ fn append_stage5_output_openings<'c, 'a>(
             &[address_chunk, instruction_cycle],
         )?;
         let eval_symbol = format!("stage5.instruction_read_raf.eval.{oracle}");
+        instruction_ra_eval_symbols.push(eval_symbol.clone());
         let eval = append_sumcheck_eval(
             context,
             module,
@@ -793,6 +827,14 @@ fn append_stage5_output_openings<'c, 'a>(
             },
         )?);
     }
+    append_sumcheck_eval_family(
+        context,
+        module,
+        "stage5.instruction_read_raf.eval.InstructionRa",
+        "stage5.sumcheck",
+        "InstructionRa",
+        &instruction_ra_eval_symbols,
+    )?;
 
     let raf_flag_eval_index = params.lookup_table_count + params.instruction_ra_virtual_d;
     let raf_flag_eval = append_sumcheck_eval(
@@ -940,7 +982,157 @@ fn append_stage5_output_openings<'c, 'a>(
         &claims,
         &["!piop.opening_batch_type"],
     )?;
-    Ok(())
+    Ok(Stage5OutputEvals {
+        ram_ra: ram_ra_eval,
+        rd_inc: rd_inc_eval,
+        rd_wa: rd_wa_eval,
+    })
+}
+
+#[expect(clippy::too_many_arguments)]
+fn append_stage5_output_claims<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    inputs: &Stage5OpeningInputs<'c, 'a>,
+    ram: (Value<'c, 'a>, Value<'c, 'a>),
+    registers: (Value<'c, 'a>, Value<'c, 'a>),
+    output_evals: &Stage5OutputEvals<'c, 'a>,
+    ram_gamma: Value<'c, 'a>,
+    ram_gamma2: Value<'c, 'a>,
+) -> Result<(), MlirError> {
+    let ram_raf_eq = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"),
+        },
+        ram.0,
+        inputs.ram_ra_raf.point,
+    )?;
+    let ram_rw_eq = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"),
+        },
+        ram.0,
+        inputs.ram_ra_rw.point,
+    )?;
+    let ram_val_eq = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"),
+        },
+        ram.0,
+        inputs.ram_ra_val.point,
+    )?;
+    let ram_rw_term = append_field_mul(
+        context,
+        module,
+        "stage5.ram_ra_claim_reduction.output.term.ReadWrite",
+        ram_gamma,
+        ram_rw_eq,
+    )?;
+    let ram_val_term = append_field_mul(
+        context,
+        module,
+        "stage5.ram_ra_claim_reduction.output.term.ValCheck",
+        ram_gamma2,
+        ram_val_eq,
+    )?;
+    let ram_raf_rw_sum = append_field_add(
+        context,
+        module,
+        "stage5.ram_ra_claim_reduction.output.partial.RafReadWrite",
+        ram_raf_eq,
+        ram_rw_term,
+    )?;
+    let ram_eq_combined = append_field_add(
+        context,
+        module,
+        "stage5.ram_ra_claim_reduction.output.eq_combined",
+        ram_raf_rw_sum,
+        ram_val_term,
+    )?;
+    let ram_output_claim = append_field_mul(
+        context,
+        module,
+        "stage5.ram_ra_claim_reduction.output.claim_expr",
+        ram_eq_combined,
+        output_evals.ram_ra,
+    )?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage5.ram_ra_claim_reduction.output.claim",
+            stage: "stage5",
+            relation: "jolt.stage5.ram_ra_claim_reduction",
+        },
+        ram_output_claim,
+        &[
+            ("stage5.ram_ra_claim_reduction.output.eq.Raf", ram_raf_eq),
+            (
+                "stage5.ram_ra_claim_reduction.output.eq.ReadWrite",
+                ram_rw_eq,
+            ),
+            (
+                "stage5.ram_ra_claim_reduction.output.eq.ValCheck",
+                ram_val_eq,
+            ),
+        ],
+    )?;
+
+    let registers_lt = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle",
+            polynomial: "lt",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"),
+        },
+        registers.0,
+        inputs.registers_val.point,
+    )?;
+    let registers_eval_product = append_field_mul(
+        context,
+        module,
+        "stage5.registers_val_evaluation.output.product.RdIncRdWa",
+        output_evals.rd_inc,
+        output_evals.rd_wa,
+    )?;
+    let registers_output_claim = append_field_mul(
+        context,
+        module,
+        "stage5.registers_val_evaluation.output.claim_expr",
+        registers_eval_product,
+        registers_lt,
+    )?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage5.registers_val_evaluation.output.claim",
+            stage: "stage5",
+            relation: "jolt.stage5.registers_val_evaluation",
+        },
+        registers_output_claim,
+        &[(
+            "stage5.registers_val_evaluation.output.lt.RegistersValCycle",
+            registers_lt,
+        )],
+    )
 }
 
 fn append_opening_claim_equal<'c>(
@@ -1169,6 +1361,29 @@ fn append_sumcheck_eval<'c, 'a>(
     first_result(op, "piop.sumcheck_eval")
 }
 
+fn append_sumcheck_eval_family(
+    context: &MeliorContext,
+    module: &BoltModule<'_, Protocol>,
+    symbol: &str,
+    source: &str,
+    oracle_family: &str,
+    evals: &[String],
+) -> Result<(), MlirError> {
+    let eval_symbols = evals.iter().map(String::as_str).collect::<Vec<_>>();
+    context.append_op(
+        module,
+        "piop.sumcheck_eval_family",
+        Some(symbol),
+        &[
+            ("source", &format!("@{}", source)),
+            ("oracle_family", &format!("@{}", oracle_family)),
+            ("count", &int_attr(eval_symbols.len())),
+            ("evals", &symbol_array_attr(&eval_symbols)),
+        ],
+    )?;
+    Ok(())
+}
+
 fn append_point_slice<'c, 'a>(
     context: &'c MeliorContext,
     module: &'a BoltModule<'c, Protocol>,
@@ -1305,6 +1520,12 @@ struct Stage5OpeningInputs<'c, 'a> {
     registers_val: Stage5OpeningInput<'c, 'a>,
 }
 
+struct Stage5OutputEvals<'c, 'a> {
+    ram_ra: Value<'c, 'a>,
+    rd_inc: Value<'c, 'a>,
+    rd_wa: Value<'c, 'a>,
+}
+
 struct StageOpeningInputSpec<'a> {
     symbol: &'a str,
     source_stage: &'a str,
diff --git a/crates/bolt/src/protocols/jolt/phases/stage6.rs b/crates/bolt/src/protocols/jolt/phases/stage6.rs
index 2e474f42c5..bae00ce176 100644
--- a/crates/bolt/src/protocols/jolt/phases/stage6.rs
+++ b/crates/bolt/src/protocols/jolt/phases/stage6.rs
@@ -10,6 +10,13 @@ use crate::schema::{verify_protocol_schema, SchemaError};
 use super::super::oracles;
 use super::super::params::JoltProtocolParams;
 use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type};
+use super::sumcheck_output::{
+    append_structured_polynomial_eval, append_sumcheck_output_claim,
+    append_sumcheck_output_eval_family, append_sumcheck_output_function_family,
+    append_sumcheck_output_product_family, OutputClaimSpec, OutputEvalFamilySpec,
+    OutputFunctionFamilySpec, OutputFunctionFamilyTermSpec, OutputProductFamilySpec,
+    OutputProductFamilyTermSpec, StructuredPolynomialPointSpec, StructuredPolynomialSpec,
+};
 
 const BOOLEANITY_DEGREE: usize = 3;
 const HAMMING_BOOLEANITY_DEGREE: usize = 3;
@@ -136,7 +143,6 @@ pub fn build_stage6_protocol<'c>(
         "challenge_scalar",
         1,
     )?;
-    append_booleanity_power_placeholders(context, &module, params, booleanity_gamma)?;
     let (state, inst_ra_gamma) = append_transcript_squeeze(
         context,
         &module,
@@ -170,6 +176,7 @@ pub fn build_stage6_protocol<'c>(
             bc_stage3_gamma,
             bc_stage4_gamma,
             bc_stage5_gamma,
+            booleanity_gamma,
             inst_ra_gamma,
             inc_gamma,
         },
@@ -904,34 +911,6 @@ fn append_transcript_squeeze<'c, 'a>(
     ))
 }
 
-fn append_booleanity_power_placeholders<'c, 'a>(
-    context: &'c MeliorContext,
-    module: &'a BoltModule<'c, Protocol>,
-    params: &JoltProtocolParams,
-    booleanity_gamma: Value<'c, 'a>,
-) -> Result<(), MlirError> {
-    let total = total_ra_oracles(params);
-    for index in 0..total {
-        let _ = append_field_pow(
-            context,
-            module,
-            &format!("stage6.booleanity.gamma_sq_{index}"),
-            booleanity_gamma,
-            2 * index,
-        )?;
-    }
-    for index in 0..total {
-        let _ = append_field_pow(
-            context,
-            module,
-            &format!("stage6.booleanity.gamma_pow_{index}"),
-            booleanity_gamma,
-            index,
-        )?;
-    }
-    Ok(())
-}
-
 fn append_stage6_batched_sumcheck<'c, 'a>(
     context: &'c MeliorContext,
     module: &'a BoltModule<'c, Protocol>,
@@ -1188,7 +1167,7 @@ fn append_stage6_batched_sumcheck<'c, 'a>(
             degree: INC_CLAIM_REDUCTION_DEGREE,
         },
     )?;
-    append_stage6_output_openings(
+    let output_evals = append_stage6_output_openings(
         context,
         module,
         params,
@@ -1200,6 +1179,21 @@ fn append_stage6_batched_sumcheck<'c, 'a>(
         instruction,
         inc,
     )?;
+    append_stage6_output_claims(
+        context,
+        module,
+        params,
+        inputs,
+        booleanity,
+        hamming,
+        ram,
+        instruction,
+        inc,
+        &output_evals,
+        spec.booleanity_gamma,
+        spec.inst_ra_gamma,
+        spec.inc_gamma,
+    )?;
     Ok(state)
 }
 
@@ -1421,9 +1415,14 @@ fn append_stage6_output_openings<'c, 'a>(
     ram: (Value<'c, 'a>, Value<'c, 'a>),
     instruction: (Value<'c, 'a>, Value<'c, 'a>),
     inc: (Value<'c, 'a>, Value<'c, 'a>),
-) -> Result<(), MlirError> {
+) -> Result<Stage6OutputEvals<'c, 'a>, MlirError> {
     let mut claims = Vec::new();
     let mut claim_symbols = Vec::new();
+    let mut booleanity_ra = Vec::with_capacity(total_ra_oracles(params));
+    let mut ram_ra = Vec::with_capacity(params.ram_d);
+    let mut instruction_ra = Vec::with_capacity(params.instruction_d);
+    let mut ram_inc = None;
+    let mut rd_inc = None;
 
     let bytecode_cycle = append_point_slice(
         context,
@@ -1434,9 +1433,11 @@ fn append_stage6_output_openings<'c, 'a>(
         params.log_t,
         bytecode.0,
     )?;
+    let mut bytecode_ra_eval_symbols = Vec::with_capacity(params.bytecode_d);
     for index in 0..params.bytecode_d {
         let oracle = format!("BytecodeRa_{index}");
         let eval_symbol = format!("stage6.bytecode_read_raf.eval.{oracle}");
+        bytecode_ra_eval_symbols.push(eval_symbol.clone());
         let eval = append_sumcheck_eval(
             context,
             module,
@@ -1480,10 +1481,18 @@ fn append_stage6_output_openings<'c, 'a>(
             },
         )?);
     }
+    append_sumcheck_eval_family(
+        context,
+        module,
+        "stage6.bytecode_read_raf.eval.BytecodeRa",
+        "stage6.sumcheck",
+        "BytecodeRa",
+        &bytecode_ra_eval_symbols,
+    )?;
 
     let mut eval_index = 0;
     for index in 0..params.instruction_d {
-        append_booleanity_output_opening(
+        booleanity_ra.push(append_booleanity_output_opening(
             context,
             module,
             params,
@@ -1492,11 +1501,11 @@ fn append_stage6_output_openings<'c, 'a>(
             booleanity,
             &format!("InstructionRa_{index}"),
             eval_index,
-        )?;
+        )?);
         eval_index += 1;
     }
     for index in 0..params.bytecode_d {
-        append_booleanity_output_opening(
+        booleanity_ra.push(append_booleanity_output_opening(
             context,
             module,
             params,
@@ -1505,11 +1514,11 @@ fn append_stage6_output_openings<'c, 'a>(
             booleanity,
             &format!("BytecodeRa_{index}"),
             eval_index,
-        )?;
+        )?);
         eval_index += 1;
     }
     for index in 0..params.ram_d {
-        append_booleanity_output_opening(
+        booleanity_ra.push(append_booleanity_output_opening(
             context,
             module,
             params,
@@ -1518,7 +1527,7 @@ fn append_stage6_output_openings<'c, 'a>(
             booleanity,
             &format!("RamRa_{index}"),
             eval_index,
-        )?;
+        )?);
         eval_index += 1;
     }
 
@@ -1576,6 +1585,7 @@ fn append_stage6_output_openings<'c, 'a>(
             index,
             ram.1,
         )?;
+        ram_ra.push(eval);
         claim_symbols.push(symbol.clone());
         claims.push(append_opening_claim(
             context,
@@ -1624,6 +1634,7 @@ fn append_stage6_output_openings<'c, 'a>(
             index,
             instruction.1,
         )?;
+        instruction_ra.push(eval);
         claim_symbols.push(symbol.clone());
         claims.push(append_opening_claim(
             context,
@@ -1651,6 +1662,11 @@ fn append_stage6_output_openings<'c, 'a>(
             index,
             inc.1,
         )?;
+        if *oracle == "RamInc" {
+            ram_inc = Some(eval);
+        } else {
+            rd_inc = Some(eval);
+        }
         claim_symbols.push(symbol.clone());
         claims.push(append_opening_claim(
             context,
@@ -1682,7 +1698,436 @@ fn append_stage6_output_openings<'c, 'a>(
         &claims,
         &["!piop.opening_batch_type"],
     )?;
-    Ok(())
+    Ok(Stage6OutputEvals {
+        booleanity_ra,
+        hamming_weight: hamming_eval,
+        ram_ra,
+        instruction_ra,
+        ram_inc: ram_inc.ok_or_else(|| schema_error("missing stage6 RamInc output eval"))?,
+        rd_inc: rd_inc.ok_or_else(|| schema_error("missing stage6 RdInc output eval"))?,
+    })
+}
+
+#[expect(clippy::too_many_arguments)]
+fn append_stage6_output_claims<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    params: &JoltProtocolParams,
+    inputs: &Stage6OpeningInputs<'c, 'a>,
+    booleanity: (Value<'c, 'a>, Value<'c, 'a>),
+    hamming: (Value<'c, 'a>, Value<'c, 'a>),
+    ram: (Value<'c, 'a>, Value<'c, 'a>),
+    instruction: (Value<'c, 'a>, Value<'c, 'a>),
+    inc: (Value<'c, 'a>, Value<'c, 'a>),
+    output_evals: &Stage6OutputEvals<'c, 'a>,
+    booleanity_gamma: Value<'c, 'a>,
+    instruction_gamma: Value<'c, 'a>,
+    inc_gamma: Value<'c, 'a>,
+) -> Result<(), MlirError> {
+    append_stage6_booleanity_output_claim(
+        context,
+        module,
+        params,
+        inputs,
+        booleanity,
+        output_evals,
+        booleanity_gamma,
+    )?;
+    append_stage6_hamming_output_claim(context, module, inputs, hamming, output_evals)?;
+    append_stage6_ram_ra_virtual_output_claim(context, module, inputs, ram, output_evals)?;
+    append_stage6_instruction_ra_virtual_output_claim(
+        context,
+        module,
+        params,
+        inputs,
+        instruction,
+        output_evals,
+        instruction_gamma,
+    )?;
+    append_stage6_inc_output_claim(context, module, inputs, inc, output_evals, inc_gamma)
+}
+
+fn append_stage6_booleanity_output_claim<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    params: &JoltProtocolParams,
+    inputs: &Stage6OpeningInputs<'c, 'a>,
+    booleanity: (Value<'c, 'a>, Value<'c, 'a>),
+    output_evals: &Stage6OutputEvals<'c, 'a>,
+    gamma: Value<'c, 'a>,
+) -> Result<(), MlirError> {
+    let instruction_ra0 = inputs
+        .instruction_ra_virtual
+        .first()
+        .ok_or_else(|| schema_error("stage6 Booleanity output requires InstructionRa_0 input"))?;
+    let address = append_point_slice(
+        context,
+        module,
+        "stage6.booleanity.output.point.Address",
+        "stage6.input.stage5.instruction_read_raf.InstructionRa_0",
+        0,
+        params.log_k_chunk,
+        instruction_ra0.point,
+    )?;
+    let cycle = append_point_slice(
+        context,
+        module,
+        "stage6.booleanity.output.point.Cycle",
+        "stage6.input.stage5.instruction_read_raf.InstructionRa_0",
+        params.lookups_ra_virtual_log_k_chunk,
+        params.log_t,
+        instruction_ra0.point,
+    )?;
+    let expected_point = append_point_concat(
+        context,
+        module,
+        "stage6.booleanity.output.point",
+        "address_prefix_then_cycle",
+        booleanity_rounds(params),
+        &[address, cycle],
+    )?;
+    let eq = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage6.booleanity.output.eq.InstructionRa0",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("as_is"),
+            y_point: StructuredPolynomialPointSpec::full("as_is"),
+        },
+        booleanity.0,
+        expected_point,
+    )?;
+    let family_terms = output_evals
+        .booleanity_ra
+        .iter()
+        .enumerate()
+        .map(|(index, (symbol, eval))| OutputFunctionFamilyTermSpec {
+            gamma_power_offset: 2 * index,
+            function: "boolean_zero",
+            eval: (symbol.clone(), *eval),
+            factors: vec![("stage6.booleanity.output.eq.InstructionRa0".to_owned(), eq)],
+        })
+        .collect::<Vec<_>>();
+    let claim = append_sumcheck_output_function_family(
+        context,
+        module,
+        OutputFunctionFamilySpec {
+            symbol: "stage6.booleanity.output.family",
+        },
+        Some(("stage6.booleanity.gamma", gamma)),
+        &family_terms,
+    )?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage6.booleanity.output.claim",
+            stage: "stage6",
+            relation: "jolt.stage6.booleanity",
+        },
+        claim,
+        &[("stage6.booleanity.output.eq.InstructionRa0", eq)],
+    )
+}
+
+fn append_stage6_hamming_output_claim<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    inputs: &Stage6OpeningInputs<'c, 'a>,
+    hamming: (Value<'c, 'a>, Value<'c, 'a>),
+    output_evals: &Stage6OutputEvals<'c, 'a>,
+) -> Result<(), MlirError> {
+    let eq_lookup = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage6.hamming_booleanity.output.eq.LookupOutput",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("as_is"),
+            y_point: StructuredPolynomialPointSpec::full("reverse"),
+        },
+        hamming.0,
+        inputs.hamming_lookup_output.point,
+    )?;
+    let claim = append_sumcheck_output_function_family(
+        context,
+        module,
+        OutputFunctionFamilySpec {
+            symbol: "stage6.hamming_booleanity.output.family",
+        },
+        None,
+        &[OutputFunctionFamilyTermSpec {
+            gamma_power_offset: 0,
+            function: "boolean_zero",
+            eval: (
+                "stage6.hamming_booleanity.eval.HammingWeight".to_owned(),
+                output_evals.hamming_weight,
+            ),
+            factors: vec![(
+                "stage6.hamming_booleanity.output.eq.LookupOutput".to_owned(),
+                eq_lookup,
+            )],
+        }],
+    )?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage6.hamming_booleanity.output.claim",
+            stage: "stage6",
+            relation: "jolt.stage6.hamming_booleanity",
+        },
+        claim,
+        &[(
+            "stage6.hamming_booleanity.output.eq.LookupOutput",
+            eq_lookup,
+        )],
+    )
+}
+
+fn append_stage6_ram_ra_virtual_output_claim<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    inputs: &Stage6OpeningInputs<'c, 'a>,
+    ram: (Value<'c, 'a>, Value<'c, 'a>),
+    output_evals: &Stage6OutputEvals<'c, 'a>,
+) -> Result<(), MlirError> {
+    let eq_cycle = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage6.ram_ra_virtual.output.eq.Cycle",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"),
+        },
+        ram.0,
+        inputs.ram_ra_virtual.point,
+    )?;
+    let claim = append_sumcheck_output_product_family(
+        context,
+        module,
+        OutputProductFamilySpec {
+            symbol: "stage6.ram_ra_virtual.output.family",
+        },
+        None,
+        &[OutputProductFamilyTermSpec {
+            gamma_power_offset: 0,
+            evals: output_evals
+                .ram_ra
+                .iter()
+                .enumerate()
+                .map(|(index, eval)| (format!("stage6.ram_ra_virtual.eval.RamRa_{index}"), *eval))
+                .collect(),
+            factors: vec![("stage6.ram_ra_virtual.output.eq.Cycle".to_owned(), eq_cycle)],
+        }],
+    )?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage6.ram_ra_virtual.output.claim",
+            stage: "stage6",
+            relation: "jolt.stage6.ram_ra_virtual",
+        },
+        claim,
+        &[("stage6.ram_ra_virtual.output.eq.Cycle", eq_cycle)],
+    )
+}
+
+fn append_stage6_instruction_ra_virtual_output_claim<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    params: &JoltProtocolParams,
+    inputs: &Stage6OpeningInputs<'c, 'a>,
+    instruction: (Value<'c, 'a>, Value<'c, 'a>),
+    output_evals: &Stage6OutputEvals<'c, 'a>,
+    gamma: Value<'c, 'a>,
+) -> Result<(), MlirError> {
+    let eq_cycle = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: "stage6.instruction_ra_virtual.output.eq.Cycle",
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"),
+        },
+        instruction.0,
+        inputs.instruction_ra_virtual[0].point,
+    )?;
+    let committed_per_virtual = n_committed_per_virtual(params);
+    let mut family_terms = Vec::with_capacity(inputs.instruction_ra_virtual.len());
+    for (virtual_index, chunk) in output_evals
+        .instruction_ra
+        .chunks(committed_per_virtual)
+        .enumerate()
+    {
+        family_terms.push(OutputProductFamilyTermSpec {
+            gamma_power_offset: virtual_index,
+            evals: chunk
+                .iter()
+                .enumerate()
+                .map(|(chunk_index, eval)| {
+                    let index = virtual_index * committed_per_virtual + chunk_index;
+                    (
+                        format!("stage6.instruction_ra_virtual.eval.InstructionRa_{index}"),
+                        *eval,
+                    )
+                })
+                .collect(),
+            factors: vec![(
+                "stage6.instruction_ra_virtual.output.eq.Cycle".to_owned(),
+                eq_cycle,
+            )],
+        });
+    }
+    let claim = append_sumcheck_output_product_family(
+        context,
+        module,
+        OutputProductFamilySpec {
+            symbol: "stage6.instruction_ra_virtual.output.family",
+        },
+        Some(("stage6.instruction_ra_virtual.gamma", gamma)),
+        &family_terms,
+    )?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage6.instruction_ra_virtual.output.claim",
+            stage: "stage6",
+            relation: "jolt.stage6.instruction_ra_virtual",
+        },
+        claim,
+        &[("stage6.instruction_ra_virtual.output.eq.Cycle", eq_cycle)],
+    )
+}
+
+fn append_stage6_inc_output_claim<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    inputs: &Stage6OpeningInputs<'c, 'a>,
+    inc: (Value<'c, 'a>, Value<'c, 'a>),
+    output_evals: &Stage6OutputEvals<'c, 'a>,
+    gamma: Value<'c, 'a>,
+) -> Result<(), MlirError> {
+    let eq_ram_stage2 = append_stage6_inc_eq(
+        context,
+        module,
+        "stage6.inc_claim_reduction.output.eq.RamIncStage2",
+        inc.0,
+        inputs.ram_inc_stage2.point,
+    )?;
+    let eq_ram_stage4 = append_stage6_inc_eq(
+        context,
+        module,
+        "stage6.inc_claim_reduction.output.eq.RamIncStage4",
+        inc.0,
+        inputs.ram_inc_stage4.point,
+    )?;
+    let eq_rd_stage4 = append_stage6_inc_eq(
+        context,
+        module,
+        "stage6.inc_claim_reduction.output.eq.RdIncStage4",
+        inc.0,
+        inputs.rd_inc_stage4.point,
+    )?;
+    let eq_rd_stage5 = append_stage6_inc_eq(
+        context,
+        module,
+        "stage6.inc_claim_reduction.output.eq.RdIncStage5",
+        inc.0,
+        inputs.rd_inc_stage5.point,
+    )?;
+    let claim = append_sumcheck_output_eval_family(
+        context,
+        module,
+        OutputEvalFamilySpec {
+            symbol: "stage6.inc_claim_reduction.output.family",
+            power_stride: 2,
+            value_term_offsets: &[],
+            shared_term_offsets: &[],
+            item_term_offsets: &[0, 1],
+        },
+        gamma,
+        &[
+            (
+                "stage6.inc_claim_reduction.eval.RamInc",
+                output_evals.ram_inc,
+            ),
+            ("stage6.inc_claim_reduction.eval.RdInc", output_evals.rd_inc),
+        ],
+        &[],
+        &[
+            (
+                "stage6.inc_claim_reduction.output.eq.RamIncStage2",
+                eq_ram_stage2,
+            ),
+            (
+                "stage6.inc_claim_reduction.output.eq.RdIncStage4",
+                eq_rd_stage4,
+            ),
+            (
+                "stage6.inc_claim_reduction.output.eq.RamIncStage4",
+                eq_ram_stage4,
+            ),
+            (
+                "stage6.inc_claim_reduction.output.eq.RdIncStage5",
+                eq_rd_stage5,
+            ),
+        ],
+    )?;
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage6.inc_claim_reduction.output.claim",
+            stage: "stage6",
+            relation: "jolt.stage6.inc_claim_reduction",
+        },
+        claim,
+        &[
+            (
+                "stage6.inc_claim_reduction.output.eq.RamIncStage2",
+                eq_ram_stage2,
+            ),
+            (
+                "stage6.inc_claim_reduction.output.eq.RamIncStage4",
+                eq_ram_stage4,
+            ),
+            (
+                "stage6.inc_claim_reduction.output.eq.RdIncStage4",
+                eq_rd_stage4,
+            ),
+            (
+                "stage6.inc_claim_reduction.output.eq.RdIncStage5",
+                eq_rd_stage5,
+            ),
+        ],
+    )
+}
+
+fn append_stage6_inc_eq<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    symbol: &str,
+    instance_point: Value<'c, 'a>,
+    input_point: Value<'c, 'a>,
+) -> Result<Value<'c, 'a>, MlirError> {
+    append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol,
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"),
+        },
+        instance_point,
+        input_point,
+    )
 }
 
 #[expect(clippy::too_many_arguments)]
@@ -1695,12 +2140,13 @@ fn append_booleanity_output_opening<'c, 'a>(
     booleanity: (Value<'c, 'a>, Value<'c, 'a>),
     oracle: &str,
     eval_index: usize,
-) -> Result<(), MlirError> {
+) -> Result<(String, Value<'c, 'a>), MlirError> {
     let symbol = format!("stage6.booleanity.opening.{oracle}");
+    let eval_symbol = format!("stage6.booleanity.eval.{oracle}");
     let eval = append_sumcheck_eval(
         context,
         module,
-        &format!("stage6.booleanity.eval.{oracle}"),
+        &eval_symbol,
         "stage6.sumcheck",
         oracle,
         eval_index,
@@ -1720,7 +2166,7 @@ fn append_booleanity_output_opening<'c, 'a>(
             claim_kind: "committed",
         },
     )?);
-    Ok(())
+    Ok((eval_symbol, eval))
 }
 
 fn append_field_zero<'c, 'a>(
@@ -1969,6 +2415,29 @@ fn append_sumcheck_eval<'c, 'a>(
     first_result(op, "piop.sumcheck_eval")
 }
 
+fn append_sumcheck_eval_family(
+    context: &MeliorContext,
+    module: &BoltModule<'_, Protocol>,
+    symbol: &str,
+    source: &str,
+    oracle_family: &str,
+    evals: &[String],
+) -> Result<(), MlirError> {
+    let eval_symbols = evals.iter().map(String::as_str).collect::<Vec<_>>();
+    context.append_op(
+        module,
+        "piop.sumcheck_eval_family",
+        Some(symbol),
+        &[
+            ("source", &format!("@{}", source)),
+            ("oracle_family", &format!("@{}", oracle_family)),
+            ("count", &int_attr(eval_symbols.len())),
+            ("evals", &symbol_array_attr(&eval_symbols)),
+        ],
+    )?;
+    Ok(())
+}
+
 fn append_point_slice<'c, 'a>(
     context: &'c MeliorContext,
     module: &'a BoltModule<'c, Protocol>,
@@ -2212,6 +2681,7 @@ struct Stage6BatchedSumcheckInputs<'c, 'a, 'b> {
     bc_stage3_gamma: Value<'c, 'a>,
     bc_stage4_gamma: Value<'c, 'a>,
     bc_stage5_gamma: Value<'c, 'a>,
+    booleanity_gamma: Value<'c, 'a>,
     inst_ra_gamma: Value<'c, 'a>,
     inc_gamma: Value<'c, 'a>,
 }
@@ -2227,6 +2697,15 @@ struct Stage6OpeningInputs<'c, 'a> {
     rd_inc_stage5: Stage6OpeningInput<'c, 'a>,
 }
 
+struct Stage6OutputEvals<'c, 'a> {
+    booleanity_ra: Vec<(String, Value<'c, 'a>)>,
+    hamming_weight: Value<'c, 'a>,
+    ram_ra: Vec<Value<'c, 'a>>,
+    instruction_ra: Vec<Value<'c, 'a>>,
+    ram_inc: Value<'c, 'a>,
+    rd_inc: Value<'c, 'a>,
+}
+
 struct Stage6OpeningInput<'c, 'a> {
     point: Value<'c, 'a>,
     eval: Value<'c, 'a>,
diff --git a/crates/bolt/src/protocols/jolt/phases/stage7.rs b/crates/bolt/src/protocols/jolt/phases/stage7.rs
index c37568c3d3..8f3b6944eb 100644
--- a/crates/bolt/src/protocols/jolt/phases/stage7.rs
+++ b/crates/bolt/src/protocols/jolt/phases/stage7.rs
@@ -8,6 +8,11 @@ use crate::schema::{verify_protocol_schema, SchemaError};
 use super::super::oracles;
 use super::super::params::JoltProtocolParams;
 use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type};
+use super::sumcheck_output::{
+    append_structured_polynomial_eval, append_sumcheck_output_claim,
+    append_sumcheck_output_eval_family, OutputClaimSpec, OutputEvalFamilySpec,
+    StructuredPolynomialPointSpec, StructuredPolynomialSpec,
+};
 
 const HAMMING_WEIGHT_CLAIM_REDUCTION_DEGREE: usize = 2;
 
@@ -450,7 +455,7 @@ fn append_stage7_sumcheck<'c, 'a>(
         point,
         result_value,
     )?;
-    append_stage7_output_openings(context, module, params, spec.openings, instance)?;
+    append_stage7_output_openings(context, module, params, spec.openings, spec.gamma, instance)?;
     Ok(state)
 }
 
@@ -532,6 +537,7 @@ fn append_stage7_output_openings<'c, 'a>(
     module: &'a BoltModule<'c, Protocol>,
     params: &JoltProtocolParams,
     inputs: &Stage7OpeningInputs<'c, 'a>,
+    gamma: Value<'c, 'a>,
     instance: (Value<'c, 'a>, Value<'c, 'a>),
 ) -> Result<(), MlirError> {
     let cycle = append_point_slice(
@@ -554,6 +560,7 @@ fn append_stage7_output_openings<'c, 'a>(
 
     let mut claims = Vec::with_capacity(inputs.ra_inputs.len());
     let mut claim_symbols = Vec::with_capacity(inputs.ra_inputs.len());
+    let mut output_evals = Vec::with_capacity(inputs.ra_inputs.len());
     for (index, input) in inputs.ra_inputs.iter().enumerate() {
         let eval = append_sumcheck_eval(
             context,
@@ -567,6 +574,7 @@ fn append_stage7_output_openings<'c, 'a>(
             index,
             instance.1,
         )?;
+        output_evals.push(eval);
         let symbol = format!(
             "stage7.hamming_weight_claim_reduction.opening.{}",
             input.oracle
@@ -586,6 +594,7 @@ fn append_stage7_output_openings<'c, 'a>(
             },
         )?);
     }
+    append_stage7_output_claim(context, module, inputs, instance.0, gamma, &output_evals)?;
     let claim_names = claim_symbols.iter().map(String::as_str).collect::<Vec<_>>();
     let _batch = context.append_typed_op(
         module,
@@ -604,6 +613,99 @@ fn append_stage7_output_openings<'c, 'a>(
     Ok(())
 }
 
+fn append_stage7_output_claim<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    inputs: &Stage7OpeningInputs<'c, 'a>,
+    instance_point: Value<'c, 'a>,
+    gamma: Value<'c, 'a>,
+    output_evals: &[Value<'c, 'a>],
+) -> Result<(), MlirError> {
+    let booleanity_eq_symbol = "stage7.hamming_weight_claim_reduction.output.eq.Booleanity";
+    let booleanity_eq = append_structured_polynomial_eval(
+        context,
+        module,
+        StructuredPolynomialSpec {
+            symbol: booleanity_eq_symbol,
+            polynomial: "eq",
+            x_point: StructuredPolynomialPointSpec::full("reverse"),
+            y_point: StructuredPolynomialPointSpec::prefix("x_point", "as_is"),
+        },
+        instance_point,
+        inputs.booleanity_point,
+    )?;
+
+    let mut polynomial_evals = Vec::with_capacity(output_evals.len() + 1);
+    polynomial_evals.push((booleanity_eq_symbol.to_owned(), booleanity_eq));
+    let mut eval_terms = Vec::with_capacity(output_evals.len());
+    let mut item_terms = Vec::with_capacity(output_evals.len());
+    for (input, &output_eval) in inputs.ra_inputs.iter().zip(output_evals) {
+        let virtualization_eq_symbol = format!(
+            "stage7.hamming_weight_claim_reduction.output.eq.{}.virtualization",
+            input.oracle
+        );
+        let virtualization_eq = append_structured_polynomial_eval(
+            context,
+            module,
+            StructuredPolynomialSpec {
+                symbol: &virtualization_eq_symbol,
+                polynomial: "eq",
+                x_point: StructuredPolynomialPointSpec::full("reverse"),
+                y_point: StructuredPolynomialPointSpec::prefix("x_point", "as_is"),
+            },
+            instance_point,
+            input.virtualization.point,
+        )?;
+        polynomial_evals.push((virtualization_eq_symbol.clone(), virtualization_eq));
+        eval_terms.push((
+            format!(
+                "stage7.hamming_weight_claim_reduction.eval.{}",
+                input.oracle
+            ),
+            output_eval,
+        ));
+        item_terms.push((virtualization_eq_symbol, virtualization_eq));
+    }
+    let eval_term_refs = eval_terms
+        .iter()
+        .map(|(symbol, value)| (symbol.as_str(), *value))
+        .collect::<Vec<_>>();
+    let item_term_refs = item_terms
+        .iter()
+        .map(|(symbol, value)| (symbol.as_str(), *value))
+        .collect::<Vec<_>>();
+    let output_claim = append_sumcheck_output_eval_family(
+        context,
+        module,
+        OutputEvalFamilySpec {
+            symbol: "stage7.hamming_weight_claim_reduction.output.family",
+            power_stride: 3,
+            value_term_offsets: &[0],
+            shared_term_offsets: &[1],
+            item_term_offsets: &[2],
+        },
+        gamma,
+        &eval_term_refs,
+        &[(booleanity_eq_symbol, booleanity_eq)],
+        &item_term_refs,
+    )?;
+    let polynomial_eval_refs = polynomial_evals
+        .iter()
+        .map(|(symbol, value)| (symbol.as_str(), *value))
+        .collect::<Vec<_>>();
+    append_sumcheck_output_claim(
+        context,
+        module,
+        OutputClaimSpec {
+            symbol: "stage7.hamming_weight_claim_reduction.output",
+            stage: "stage7",
+            relation: "jolt.stage7.hamming_weight_claim_reduction",
+        },
+        output_claim,
+        &polynomial_eval_refs,
+    )
+}
+
 fn append_transcript_squeeze<'c, 'a>(
     context: &'c MeliorContext,
     module: &'a BoltModule<'c, Protocol>,
diff --git a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs
new file mode 100644
index 0000000000..f0a0402bf0
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs
@@ -0,0 +1,356 @@
+use melior::ir::Value;
+
+use crate::ir::{BoltModule, Protocol};
+use crate::mlir::{MeliorContext, MlirError};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct StructuredPolynomialPointSpec<'a> {
+    segment: &'a str,
+    length: &'a str,
+    order: &'a str,
+}
+
+impl<'a> StructuredPolynomialPointSpec<'a> {
+    pub(crate) const fn full(order: &'a str) -> Self {
+        Self {
+            segment: "full",
+            length: "full",
+            order,
+        }
+    }
+
+    pub(crate) const fn prefix(length: &'a str, order: &'a str) -> Self {
+        Self {
+            segment: "prefix",
+            length,
+            order,
+        }
+    }
+
+    pub(crate) const fn suffix(length: &'a str, order: &'a str) -> Self {
+        Self {
+            segment: "suffix",
+            length,
+            order,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct StructuredPolynomialSpec<'a> {
+    pub(crate) symbol: &'a str,
+    pub(crate) polynomial: &'a str,
+    pub(crate) x_point: StructuredPolynomialPointSpec<'a>,
+    pub(crate) y_point: StructuredPolynomialPointSpec<'a>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct OutputClaimSpec<'a> {
+    pub(crate) symbol: &'a str,
+    pub(crate) stage: &'a str,
+    pub(crate) relation: &'a str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct OutputEvalFamilySpec<'a> {
+    pub(crate) symbol: &'a str,
+    pub(crate) power_stride: usize,
+    pub(crate) value_term_offsets: &'a [usize],
+    pub(crate) shared_term_offsets: &'a [usize],
+    pub(crate) item_term_offsets: &'a [usize],
+}
+
+pub(crate) struct OutputProductFamilyTermSpec<'c, 'a> {
+    pub(crate) gamma_power_offset: usize,
+    pub(crate) evals: Vec<(String, Value<'c, 'a>)>,
+    pub(crate) factors: Vec<(String, Value<'c, 'a>)>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct OutputProductFamilySpec<'a> {
+    pub(crate) symbol: &'a str,
+}
+
+pub(crate) struct OutputFunctionFamilyTermSpec<'c, 'a> {
+    pub(crate) gamma_power_offset: usize,
+    pub(crate) function: &'static str,
+    pub(crate) eval: (String, Value<'c, 'a>),
+    pub(crate) factors: Vec<(String, Value<'c, 'a>)>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct OutputFunctionFamilySpec<'a> {
+    pub(crate) symbol: &'a str,
+}
+
+pub(crate) fn append_structured_polynomial_eval<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    spec: StructuredPolynomialSpec<'_>,
+    x_point: Value<'c, 'a>,
+    y_point: Value<'c, 'a>,
+) -> Result<Value<'c, 'a>, MlirError> {
+    let op = context.append_typed_op(
+        module,
+        "piop.structured_polynomial_eval",
+        Some(spec.symbol),
+        &[
+            ("polynomial", &format!("\"{}\"", spec.polynomial)),
+            ("x_point_segment", &format!("\"{}\"", spec.x_point.segment)),
+            ("x_point_length", &format!("\"{}\"", spec.x_point.length)),
+            ("x_point_order", &format!("\"{}\"", spec.x_point.order)),
+            ("y_point_segment", &format!("\"{}\"", spec.y_point.segment)),
+            ("y_point_length", &format!("\"{}\"", spec.y_point.length)),
+            ("y_point_order", &format!("\"{}\"", spec.y_point.order)),
+        ],
+        &[x_point, y_point],
+        &["!field.scalar"],
+    )?;
+    first_result(op, "piop.structured_polynomial_eval")
+}
+
+pub(crate) fn append_sumcheck_output_claim<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    spec: OutputClaimSpec<'_>,
+    claim_value: Value<'c, 'a>,
+    polynomial_evals: &[(&str, Value<'c, 'a>)],
+) -> Result<(), MlirError> {
+    let mut operands = Vec::with_capacity(polynomial_evals.len() + 1);
+    operands.push(claim_value);
+    operands.extend(polynomial_evals.iter().map(|(_, value)| *value));
+    let local_value_symbols = polynomial_evals
+        .iter()
+        .map(|(symbol, _)| *symbol)
+        .collect::<Vec<_>>();
+    let _op = context.append_typed_op(
+        module,
+        "piop.sumcheck_output_claim",
+        Some(spec.symbol),
+        &[
+            ("stage", &format!("@{}", spec.stage)),
+            ("relation", &format!("@{}", spec.relation)),
+            ("count", &int_attr(polynomial_evals.len())),
+            ("polynomial_evals", &symbol_array_attr(&local_value_symbols)),
+        ],
+        &operands,
+        &[],
+    )?;
+    Ok(())
+}
+
+pub(crate) fn append_sumcheck_output_eval_family<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    spec: OutputEvalFamilySpec<'_>,
+    gamma: Value<'c, 'a>,
+    evals: &[(&str, Value<'c, 'a>)],
+    shared_terms: &[(&str, Value<'c, 'a>)],
+    item_terms: &[(&str, Value<'c, 'a>)],
+) -> Result<Value<'c, 'a>, MlirError> {
+    let mut operands = Vec::with_capacity(1 + evals.len() + shared_terms.len() + item_terms.len());
+    operands.push(gamma);
+    operands.extend(evals.iter().map(|(_, value)| *value));
+    operands.extend(shared_terms.iter().map(|(_, value)| *value));
+    operands.extend(item_terms.iter().map(|(_, value)| *value));
+    let eval_symbols = evals.iter().map(|(symbol, _)| *symbol).collect::<Vec<_>>();
+    let shared_symbols = shared_terms
+        .iter()
+        .map(|(symbol, _)| *symbol)
+        .collect::<Vec<_>>();
+    let item_symbols = item_terms
+        .iter()
+        .map(|(symbol, _)| *symbol)
+        .collect::<Vec<_>>();
+    let op = context.append_typed_op(
+        module,
+        "piop.sumcheck_output_eval_family",
+        Some(spec.symbol),
+        &[
+            ("power_stride", &int_attr(spec.power_stride)),
+            (
+                "value_term_offsets",
+                &usize_array_attr(spec.value_term_offsets),
+            ),
+            (
+                "shared_term_offsets",
+                &usize_array_attr(spec.shared_term_offsets),
+            ),
+            (
+                "item_term_offsets",
+                &usize_array_attr(spec.item_term_offsets),
+            ),
+            ("evals", &symbol_array_attr(&eval_symbols)),
+            ("shared_terms", &symbol_array_attr(&shared_symbols)),
+            ("item_terms", &symbol_array_attr(&item_symbols)),
+        ],
+        &operands,
+        &["!field.scalar"],
+    )?;
+    first_result(op, "piop.sumcheck_output_eval_family")
+}
+
+pub(crate) fn append_sumcheck_output_product_family<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    spec: OutputProductFamilySpec<'_>,
+    gamma: Option<(&str, Value<'c, 'a>)>,
+    terms: &[OutputProductFamilyTermSpec<'c, 'a>],
+) -> Result<Value<'c, 'a>, MlirError> {
+    let term_gamma_power_offsets = terms
+        .iter()
+        .map(|term| term.gamma_power_offset)
+        .collect::<Vec<_>>();
+    let term_eval_counts = terms
+        .iter()
+        .map(|term| term.evals.len())
+        .collect::<Vec<_>>();
+    let term_factor_counts = terms
+        .iter()
+        .map(|term| term.factors.len())
+        .collect::<Vec<_>>();
+    let mut operands = Vec::with_capacity(
+        gamma.map_or(0, |_| 1)
+            + term_eval_counts.iter().sum::<usize>()
+            + term_factor_counts.iter().sum::<usize>(),
+    );
+    if let Some((_, gamma)) = gamma {
+        operands.push(gamma);
+    }
+    operands.extend(
+        terms
+            .iter()
+            .flat_map(|term| term.evals.iter().map(|(_, value)| *value)),
+    );
+    operands.extend(
+        terms
+            .iter()
+            .flat_map(|term| term.factors.iter().map(|(_, value)| *value)),
+    );
+    let eval_symbols = terms
+        .iter()
+        .flat_map(|term| term.evals.iter().map(|(symbol, _)| symbol.as_str()))
+        .collect::<Vec<_>>();
+    let factor_symbols = terms
+        .iter()
+        .flat_map(|term| term.factors.iter().map(|(symbol, _)| symbol.as_str()))
+        .collect::<Vec<_>>();
+    let gamma_symbols = gamma.map(|(symbol, _)| vec![symbol]).unwrap_or_default();
+    let op = context.append_typed_op(
+        module,
+        "piop.sumcheck_output_product_family",
+        Some(spec.symbol),
+        &[
+            ("gamma", &symbol_array_attr(&gamma_symbols)),
+            (
+                "term_gamma_power_offsets",
+                &usize_array_attr(&term_gamma_power_offsets),
+            ),
+            ("term_eval_counts", &usize_array_attr(&term_eval_counts)),
+            ("term_factor_counts", &usize_array_attr(&term_factor_counts)),
+            ("evals", &symbol_array_attr(&eval_symbols)),
+            ("factors", &symbol_array_attr(&factor_symbols)),
+        ],
+        &operands,
+        &["!field.scalar"],
+    )?;
+    first_result(op, "piop.sumcheck_output_product_family")
+}
+
+pub(crate) fn append_sumcheck_output_function_family<'c, 'a>(
+    context: &'c MeliorContext,
+    module: &'a BoltModule<'c, Protocol>,
+    spec: OutputFunctionFamilySpec<'_>,
+    gamma: Option<(&str, Value<'c, 'a>)>,
+    terms: &[OutputFunctionFamilyTermSpec<'c, 'a>],
+) -> Result<Value<'c, 'a>, MlirError> {
+    let term_gamma_power_offsets = terms
+        .iter()
+        .map(|term| term.gamma_power_offset)
+        .collect::<Vec<_>>();
+    let term_factor_counts = terms
+        .iter()
+        .map(|term| term.factors.len())
+        .collect::<Vec<_>>();
+    let mut operands = Vec::with_capacity(
+        gamma.map_or(0, |_| 1) + terms.len() + term_factor_counts.iter().sum::<usize>(),
+    );
+    if let Some((_, gamma)) = gamma {
+        operands.push(gamma);
+    }
+    operands.extend(terms.iter().map(|term| term.eval.1));
+    operands.extend(
+        terms
+            .iter()
+            .flat_map(|term| term.factors.iter().map(|(_, value)| *value)),
+    );
+    let functions = terms.iter().map(|term| term.function).collect::<Vec<_>>();
+    let eval_symbols = terms
+        .iter()
+        .map(|term| term.eval.0.as_str())
+        .collect::<Vec<_>>();
+    let factor_symbols = terms
+        .iter()
+        .flat_map(|term| term.factors.iter().map(|(symbol, _)| symbol.as_str()))
+        .collect::<Vec<_>>();
+    let gamma_symbols = gamma.map(|(symbol, _)| vec![symbol]).unwrap_or_default();
+    let op = context.append_typed_op(
+        module,
+        "piop.sumcheck_output_function_family",
+        Some(spec.symbol),
+        &[
+            ("gamma", &symbol_array_attr(&gamma_symbols)),
+            (
+                "term_gamma_power_offsets",
+                &usize_array_attr(&term_gamma_power_offsets),
+            ),
+            ("term_functions", &string_array_attr(&functions)),
+            ("term_factor_counts", &usize_array_attr(&term_factor_counts)),
+            ("evals", &symbol_array_attr(&eval_symbols)),
+            ("factors", &symbol_array_attr(&factor_symbols)),
+        ],
+        &operands,
+        &["!field.scalar"],
+    )?;
+    first_result(op, "piop.sumcheck_output_function_family")
+}
+
+fn first_result<'c, 'a>(
+    operation: melior::ir::operation::OperationRef<'c, 'a>,
+    operation_name: &str,
+) -> Result<Value<'c, 'a>, MlirError> {
+    operation.result(0).map(Into::into).map_err(|_| {
+        crate::schema::SchemaError::new(format!("{operation_name} requires result 0")).into()
+    })
+}
+
+fn int_attr(value: usize) -> String {
+    format!("{value} : i64")
+}
+
+fn usize_array_attr(values: &[usize]) -> String {
+    let values = values
+        .iter()
+        .map(ToString::to_string)
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("[{values}]")
+}
+
+fn symbol_array_attr(values: &[&str]) -> String {
+    let values = values
+        .iter()
+        .map(|value| format!("@{value}"))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("[{values}]")
+}
+
+fn string_array_attr(values: &[&str]) -> String {
+    let values = values
+        .iter()
+        .map(|value| format!("\"{value}\""))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("[{values}]")
+}
diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs
new file mode 100644
index 0000000000..ca434d8390
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs
@@ -0,0 +1,967 @@
+use std::fmt::{self, Display, Formatter};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct RustTargetPlanError {
+    kind: &'static str,
+    value: String,
+}
+
+impl RustTargetPlanError {
+    fn unsupported(kind: &'static str, value: &str) -> Self {
+        Self {
+            kind,
+            value: value.to_owned(),
+        }
+    }
+}
+
+impl Display for RustTargetPlanError {
+    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
+        write!(formatter, "unsupported {} `{}`", self.kind, self.value)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum ProgramStepKind {
+    TranscriptSqueeze,
+    TranscriptAbsorbBytes,
+    SumcheckDriver,
+}
+
+impl ProgramStepKind {
+    pub(crate) fn from_cpu_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "transcript_squeeze" => Ok(Self::TranscriptSqueeze),
+            "transcript_absorb_bytes" => Ok(Self::TranscriptAbsorbBytes),
+            "sumcheck_driver" => Ok(Self::SumcheckDriver),
+            _ => Err(RustTargetPlanError::unsupported("program step kind", value)),
+        }
+    }
+
+    pub(crate) fn rust_variant(self) -> &'static str {
+        match self {
+            Self::TranscriptSqueeze => "TranscriptSqueeze",
+            Self::TranscriptAbsorbBytes => "TranscriptAbsorbBytes",
+            Self::SumcheckDriver => "SumcheckDriver",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum TranscriptSqueezeKind {
+    ChallengeScalar,
+    ChallengeVector,
+    Scalar,
+}
+
+impl TranscriptSqueezeKind {
+    pub(crate) fn from_cpu_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "challenge_scalar" => Ok(Self::ChallengeScalar),
+            "challenge_vector" => Ok(Self::ChallengeVector),
+            "scalar" => Ok(Self::Scalar),
+            _ => Err(RustTargetPlanError::unsupported(
+                "transcript squeeze kind",
+                value,
+            )),
+        }
+    }
+
+    pub(crate) fn rust_variant(self) -> &'static str {
+        match self {
+            Self::ChallengeScalar => "ChallengeScalar",
+            Self::ChallengeVector => "ChallengeVector",
+            Self::Scalar => "Scalar",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum ClaimKind {
+    Committed,
+    Virtual,
+}
+
+impl ClaimKind {
+    pub(crate) fn from_cpu_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "committed" => Ok(Self::Committed),
+            "virtual" => Ok(Self::Virtual),
+            _ => Err(RustTargetPlanError::unsupported(
+                "opening claim kind",
+                value,
+            )),
+        }
+    }
+
+    pub(crate) fn rust_variant(self) -> &'static str {
+        match self {
+            Self::Committed => "Committed",
+            Self::Virtual => "Virtual",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum SumcheckPointOrder {
+    AsIs,
+    Reverse,
+    RelationLocal,
+}
+
+impl SumcheckPointOrder {
+    pub(crate) fn from_cpu_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "as_is" => Ok(Self::AsIs),
+            "reverse" => Ok(Self::Reverse),
+            "stage4_registers_rw" | "instruction_read_raf" | "bytecode_read_raf" => {
+                Ok(Self::RelationLocal)
+            }
+            "stage6_booleanity" => Ok(Self::AsIs),
+            _ => Err(RustTargetPlanError::unsupported(
+                "sumcheck point order",
+                value,
+            )),
+        }
+    }
+
+    pub(crate) fn rust_variant(self) -> &'static str {
+        match self {
+            Self::AsIs => "AsIs",
+            Self::Reverse => "Reverse",
+            Self::RelationLocal => "RelationLocal",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) enum JoltVerifierRelationKind {
+    Stage1OuterUniskip,
+    Stage1OuterRemaining,
+    Stage2ProductVirtualUniskip,
+    Stage2RamReadWrite,
+    Stage2ProductVirtualRemainder,
+    Stage2InstructionLookupClaimReduction,
+    Stage2RamRafEvaluation,
+    Stage2RamOutputCheck,
+    Stage2Batched,
+    Stage3SpartanShift,
+    Stage3InstructionInput,
+    Stage3RegistersClaimReduction,
+    Stage3Batched,
+    Stage4RegistersReadWrite,
+    Stage4RamValCheck,
+    Stage4Batched,
+    Stage5InstructionReadRaf,
+    Stage5RamRaClaimReduction,
+    Stage5RegistersValEvaluation,
+    Stage5Batched,
+    Stage6BytecodeReadRaf,
+    Stage6Booleanity,
+    Stage6HammingBooleanity,
+    Stage6RamRaVirtual,
+    Stage6InstructionRaVirtual,
+    Stage6IncClaimReduction,
+    Stage6Batched,
+    Stage7HammingWeightClaimReduction,
+    Stage7Batched,
+}
+
+impl JoltVerifierRelationKind {
+    pub(crate) fn cpu_symbol(self) -> &'static str {
+        match self {
+            Self::Stage1OuterUniskip => "jolt.stage1.outer.uniskip",
+            Self::Stage1OuterRemaining => "jolt.stage1.outer.remaining",
+            Self::Stage2ProductVirtualUniskip => "jolt.stage2.product_virtual.uniskip",
+            Self::Stage2RamReadWrite => "jolt.stage2.ram.read_write",
+            Self::Stage2ProductVirtualRemainder => "jolt.stage2.product_virtual.remainder",
+            Self::Stage2InstructionLookupClaimReduction => {
+                "jolt.stage2.instruction_lookup.claim_reduction"
+            }
+            Self::Stage2RamRafEvaluation => "jolt.stage2.ram.raf_evaluation",
+            Self::Stage2RamOutputCheck => "jolt.stage2.ram.output_check",
+            Self::Stage2Batched => "jolt.stage2.batched",
+            Self::Stage3SpartanShift => "jolt.stage3.spartan_shift",
+            Self::Stage3InstructionInput => "jolt.stage3.instruction_input",
+            Self::Stage3RegistersClaimReduction => "jolt.stage3.registers_claim_reduction",
+            Self::Stage3Batched => "jolt.stage3.batched",
+            Self::Stage4RegistersReadWrite => "jolt.stage4.registers_read_write",
+            Self::Stage4RamValCheck => "jolt.stage4.ram_val_check",
+            Self::Stage4Batched => "jolt.stage4.batched",
+            Self::Stage5InstructionReadRaf => "jolt.stage5.instruction_read_raf",
+            Self::Stage5RamRaClaimReduction => "jolt.stage5.ram_ra_claim_reduction",
+            Self::Stage5RegistersValEvaluation => "jolt.stage5.registers_val_evaluation",
+            Self::Stage5Batched => "jolt.stage5.batched",
+            Self::Stage6BytecodeReadRaf => "jolt.stage6.bytecode_read_raf",
+            Self::Stage6Booleanity => "jolt.stage6.booleanity",
+            Self::Stage6HammingBooleanity => "jolt.stage6.hamming_booleanity",
+            Self::Stage6RamRaVirtual => "jolt.stage6.ram_ra_virtual",
+            Self::Stage6InstructionRaVirtual => "jolt.stage6.instruction_ra_virtual",
+            Self::Stage6IncClaimReduction => "jolt.stage6.inc_claim_reduction",
+            Self::Stage6Batched => "jolt.stage6.batched",
+            Self::Stage7HammingWeightClaimReduction => "jolt.stage7.hamming_weight_claim_reduction",
+            Self::Stage7Batched => "jolt.stage7.batched",
+        }
+    }
+
+    pub(crate) fn from_cpu_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "jolt.stage1.outer.uniskip" => Ok(Self::Stage1OuterUniskip),
+            "jolt.stage1.outer.remaining" => Ok(Self::Stage1OuterRemaining),
+            "jolt.stage2.product_virtual.uniskip" => Ok(Self::Stage2ProductVirtualUniskip),
+            "jolt.stage2.ram.read_write" => Ok(Self::Stage2RamReadWrite),
+            "jolt.stage2.product_virtual.remainder" => Ok(Self::Stage2ProductVirtualRemainder),
+            "jolt.stage2.instruction_lookup.claim_reduction" => {
+                Ok(Self::Stage2InstructionLookupClaimReduction)
+            }
+            "jolt.stage2.ram.raf_evaluation" => Ok(Self::Stage2RamRafEvaluation),
+            "jolt.stage2.ram.output_check" => Ok(Self::Stage2RamOutputCheck),
+            "jolt.stage2.batched" => Ok(Self::Stage2Batched),
+            "jolt.stage3.spartan_shift" => Ok(Self::Stage3SpartanShift),
+            "jolt.stage3.instruction_input" => Ok(Self::Stage3InstructionInput),
+            "jolt.stage3.registers_claim_reduction" => Ok(Self::Stage3RegistersClaimReduction),
+            "jolt.stage3.batched" => Ok(Self::Stage3Batched),
+            "jolt.stage4.registers_read_write" => Ok(Self::Stage4RegistersReadWrite),
+            "jolt.stage4.ram_val_check" => Ok(Self::Stage4RamValCheck),
+            "jolt.stage4.batched" => Ok(Self::Stage4Batched),
+            "jolt.stage5.instruction_read_raf" => Ok(Self::Stage5InstructionReadRaf),
+            "jolt.stage5.ram_ra_claim_reduction" => Ok(Self::Stage5RamRaClaimReduction),
+            "jolt.stage5.registers_val_evaluation" => Ok(Self::Stage5RegistersValEvaluation),
+            "jolt.stage5.batched" => Ok(Self::Stage5Batched),
+            "jolt.stage6.bytecode_read_raf" => Ok(Self::Stage6BytecodeReadRaf),
+            "jolt.stage6.booleanity" => Ok(Self::Stage6Booleanity),
+            "jolt.stage6.hamming_booleanity" => Ok(Self::Stage6HammingBooleanity),
+            "jolt.stage6.ram_ra_virtual" => Ok(Self::Stage6RamRaVirtual),
+            "jolt.stage6.instruction_ra_virtual" => Ok(Self::Stage6InstructionRaVirtual),
+            "jolt.stage6.inc_claim_reduction" => Ok(Self::Stage6IncClaimReduction),
+            "jolt.stage6.batched" => Ok(Self::Stage6Batched),
+            "jolt.stage7.hamming_weight_claim_reduction" => {
+                Ok(Self::Stage7HammingWeightClaimReduction)
+            }
+            "jolt.stage7.batched" => Ok(Self::Stage7Batched),
+            _ => Err(RustTargetPlanError::unsupported("relation", value)),
+        }
+    }
+
+    pub(crate) fn rust_variant(self) -> &'static str {
+        match self {
+            Self::Stage1OuterUniskip => "Stage1OuterUniskip",
+            Self::Stage1OuterRemaining => "Stage1OuterRemaining",
+            Self::Stage2ProductVirtualUniskip => "Stage2ProductVirtualUniskip",
+            Self::Stage2RamReadWrite => "Stage2RamReadWrite",
+            Self::Stage2ProductVirtualRemainder => "Stage2ProductVirtualRemainder",
+            Self::Stage2InstructionLookupClaimReduction => "Stage2InstructionLookupClaimReduction",
+            Self::Stage2RamRafEvaluation => "Stage2RamRafEvaluation",
+            Self::Stage2RamOutputCheck => "Stage2RamOutputCheck",
+            Self::Stage2Batched => "Stage2Batched",
+            Self::Stage3SpartanShift => "Stage3SpartanShift",
+            Self::Stage3InstructionInput => "Stage3InstructionInput",
+            Self::Stage3RegistersClaimReduction => "Stage3RegistersClaimReduction",
+            Self::Stage3Batched => "Stage3Batched",
+            Self::Stage4RegistersReadWrite => "Stage4RegistersReadWrite",
+            Self::Stage4RamValCheck => "Stage4RamValCheck",
+            Self::Stage4Batched => "Stage4Batched",
+            Self::Stage5InstructionReadRaf => "Stage5InstructionReadRaf",
+            Self::Stage5RamRaClaimReduction => "Stage5RamRaClaimReduction",
+            Self::Stage5RegistersValEvaluation => "Stage5RegistersValEvaluation",
+            Self::Stage5Batched => "Stage5Batched",
+            Self::Stage6BytecodeReadRaf => "Stage6BytecodeReadRaf",
+            Self::Stage6Booleanity => "Stage6Booleanity",
+            Self::Stage6HammingBooleanity => "Stage6HammingBooleanity",
+            Self::Stage6RamRaVirtual => "Stage6RamRaVirtual",
+            Self::Stage6InstructionRaVirtual => "Stage6InstructionRaVirtual",
+            Self::Stage6IncClaimReduction => "Stage6IncClaimReduction",
+            Self::Stage6Batched => "Stage6Batched",
+            Self::Stage7HammingWeightClaimReduction => "Stage7HammingWeightClaimReduction",
+            Self::Stage7Batched => "Stage7Batched",
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum FieldExprKind {
+    OpeningEval,
+    Add,
+    Sub,
+    Mul,
+    Sum,
+    Product,
+    Neg,
+    Pow(usize),
+    LagrangeBasisEval {
+        domain_start: i64,
+        domain_size: usize,
+        index: usize,
+    },
+    LagrangeKernelEval {
+        domain_start: i64,
+        domain_size: usize,
+    },
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum ScalarExprKind {
+    FieldVectorSum,
+    FieldVectorProduct,
+    StructuredPolynomial {
+        polynomial: StructuredPolynomialKind,
+        x_point: StructuredPolynomialPointTransform,
+        y_point: StructuredPolynomialPointTransform,
+    },
+    PowerStridedWeightedSum {
+        row_count: usize,
+        power_stride: usize,
+        value_term_offsets: Vec<usize>,
+        shared_term_offsets: Vec<usize>,
+        row_term_offsets: Vec<usize>,
+    },
+    PointElement {
+        index: usize,
+    },
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum StructuredPolynomialKind {
+    Eq,
+    EqPlusOne,
+    Lt,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum StructuredPolynomialPointSegment {
+    Full,
+    Prefix,
+    Suffix,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum StructuredPolynomialPointLength {
+    Full,
+    XPoint,
+    YPoint,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum StructuredPolynomialPointOrder {
+    AsIs,
+    Reverse,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct StructuredPolynomialPointTransform {
+    segment: StructuredPolynomialPointSegment,
+    length: StructuredPolynomialPointLength,
+    order: StructuredPolynomialPointOrder,
+}
+
+impl FieldExprKind {
+    pub(crate) fn from_cpu_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "opening_eval" => Ok(Self::OpeningEval),
+            "field.add" => Ok(Self::Add),
+            "field.sub" => Ok(Self::Sub),
+            "field.mul" => Ok(Self::Mul),
+            "field.sum" => Ok(Self::Sum),
+            "field.product" => Ok(Self::Product),
+            "field.neg" => Ok(Self::Neg),
+            value if value.starts_with("field.pow:") => parse_pow(value),
+            value if value.starts_with("poly.lagrange_basis_eval:") => parse_lagrange(value),
+            value if value.starts_with("poly.lagrange_kernel_eval:") => {
+                parse_lagrange_kernel(value)
+            }
+            _ => Err(RustTargetPlanError::unsupported(
+                "field expression formula",
+                value,
+            )),
+        }
+    }
+
+    pub(crate) fn rust_variant_expr(&self) -> String {
+        match self {
+            Self::OpeningEval => "OpeningEval".to_owned(),
+            Self::Add => "Add".to_owned(),
+            Self::Sub => "Sub".to_owned(),
+            Self::Mul => "Mul".to_owned(),
+            Self::Sum => "Sum".to_owned(),
+            Self::Product => "Product".to_owned(),
+            Self::Neg => "Neg".to_owned(),
+            Self::Pow(exponent) => format!("Pow({exponent})"),
+            Self::LagrangeBasisEval {
+                domain_start,
+                domain_size,
+                index,
+            } => format!("LagrangeBasisEval({domain_start}, {domain_size}, {index})"),
+            Self::LagrangeKernelEval {
+                domain_start,
+                domain_size,
+            } => format!("LagrangeKernelEval({domain_start}, {domain_size})"),
+        }
+    }
+}
+
+impl ScalarExprKind {
+    pub(crate) fn from_cpu_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "field_vector.sum" => Ok(Self::FieldVectorSum),
+            "field_vector.product" => Ok(Self::FieldVectorProduct),
+            value if value.starts_with("poly.structured_eval:") => {
+                parse_structured_polynomial_scalar(value)
+            }
+            value if value.starts_with("field.power_strided_weighted_sum:") => {
+                parse_power_strided_weighted_sum(value)
+            }
+            value if value.starts_with("point.element:") => parse_point_element(value),
+            _ => Err(RustTargetPlanError::unsupported(
+                "scalar expression formula",
+                value,
+            )),
+        }
+    }
+
+    pub(crate) fn rust_variant_expr(&self) -> String {
+        match self {
+            Self::FieldVectorSum => "FieldVectorSum".to_owned(),
+            Self::FieldVectorProduct => "FieldVectorProduct".to_owned(),
+            Self::StructuredPolynomial {
+                polynomial,
+                x_point,
+                y_point,
+            } => format!(
+                "StructuredPolynomial {{ polynomial: {}, x_point: {}, y_point: {} }}",
+                polynomial.rust_variant_expr(),
+                x_point.rust_expr(),
+                y_point.rust_expr(),
+            ),
+            Self::PowerStridedWeightedSum {
+                row_count,
+                power_stride,
+                value_term_offsets,
+                shared_term_offsets,
+                row_term_offsets,
+            } => format!(
+                "PowerStridedWeightedSum {{ row_count: {row_count}, power_stride: {power_stride}, value_term_offsets: {}, shared_term_offsets: {}, row_term_offsets: {} }}",
+                usize_slice_expr(value_term_offsets),
+                usize_slice_expr(shared_term_offsets),
+                usize_slice_expr(row_term_offsets),
+            ),
+            Self::PointElement { index } => {
+                format!("PointElement {{ index: {index} }}")
+            }
+        }
+    }
+}
+
+impl StructuredPolynomialKind {
+    fn from_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "eq" => Ok(Self::Eq),
+            "eq_plus_one" => Ok(Self::EqPlusOne),
+            "lt" => Ok(Self::Lt),
+            _ => Err(RustTargetPlanError::unsupported(
+                "structured polynomial kind",
+                value,
+            )),
+        }
+    }
+
+    fn rust_variant_expr(&self) -> &'static str {
+        match self {
+            Self::Eq => "bolt_verifier_runtime::StructuredPolynomialKind::Eq",
+            Self::EqPlusOne => "bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne",
+            Self::Lt => "bolt_verifier_runtime::StructuredPolynomialKind::Lt",
+        }
+    }
+}
+
+impl StructuredPolynomialPointSegment {
+    fn from_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "full" => Ok(Self::Full),
+            "prefix" => Ok(Self::Prefix),
+            "suffix" => Ok(Self::Suffix),
+            _ => Err(RustTargetPlanError::unsupported(
+                "structured polynomial point segment",
+                value,
+            )),
+        }
+    }
+
+    fn rust_variant_expr(&self) -> &'static str {
+        match self {
+            Self::Full => "bolt_verifier_runtime::StructuredPolynomialPointSegment::Full",
+            Self::Prefix => "bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix",
+            Self::Suffix => "bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix",
+        }
+    }
+}
+
+impl StructuredPolynomialPointLength {
+    fn from_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "full" => Ok(Self::Full),
+            "x_point" => Ok(Self::XPoint),
+            "y_point" => Ok(Self::YPoint),
+            _ => Err(RustTargetPlanError::unsupported(
+                "structured polynomial point length",
+                value,
+            )),
+        }
+    }
+
+    fn rust_variant_expr(&self) -> &'static str {
+        match self {
+            Self::Full => "bolt_verifier_runtime::StructuredPolynomialPointLength::Full",
+            Self::XPoint => "bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint",
+            Self::YPoint => "bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint",
+        }
+    }
+}
+
+impl StructuredPolynomialPointOrder {
+    fn from_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "as_is" => Ok(Self::AsIs),
+            "reverse" => Ok(Self::Reverse),
+            _ => Err(RustTargetPlanError::unsupported(
+                "structured polynomial point order",
+                value,
+            )),
+        }
+    }
+
+    fn rust_variant_expr(&self) -> &'static str {
+        match self {
+            Self::AsIs => "bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs",
+            Self::Reverse => "bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse",
+        }
+    }
+}
+
+impl StructuredPolynomialPointTransform {
+    fn new(segment: &str, length: &str, order: &str) -> Result<Self, RustTargetPlanError> {
+        Ok(Self {
+            segment: StructuredPolynomialPointSegment::from_attr(segment)?,
+            length: StructuredPolynomialPointLength::from_attr(length)?,
+            order: StructuredPolynomialPointOrder::from_attr(order)?,
+        })
+    }
+
+    fn rust_expr(&self) -> String {
+        format!(
+            "bolt_verifier_runtime::StructuredPolynomialPointTransform {{ segment: {}, length: {}, order: {} }}",
+            self.segment.rust_variant_expr(),
+            self.length.rust_variant_expr(),
+            self.order.rust_variant_expr(),
+        )
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum PcsProofMode {
+    Open,
+    Verify,
+}
+
+impl PcsProofMode {
+    pub(crate) fn from_cpu_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "open" => Ok(Self::Open),
+            "verify" => Ok(Self::Verify),
+            _ => Err(RustTargetPlanError::unsupported("PCS proof mode", value)),
+        }
+    }
+
+    pub(crate) fn rust_variant(self) -> &'static str {
+        match self {
+            Self::Open => "Open",
+            Self::Verify => "Verify",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum OpeningEqualityMode {
+    PointAndEval,
+}
+
+impl OpeningEqualityMode {
+    pub(crate) fn from_cpu_attr(value: &str) -> Result<Self, RustTargetPlanError> {
+        match value {
+            "point_and_eval" => Ok(Self::PointAndEval),
+            _ => Err(RustTargetPlanError::unsupported(
+                "opening equality mode",
+                value,
+            )),
+        }
+    }
+
+    pub(crate) fn rust_variant(self) -> &'static str {
+        match self {
+            Self::PointAndEval => "PointAndEval",
+        }
+    }
+}
+
+fn parse_pow(value: &str) -> Result<FieldExprKind, RustTargetPlanError> {
+    let exponent = value
+        .strip_prefix("field.pow:")
+        .and_then(|exponent| exponent.parse::<usize>().ok())
+        .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?;
+    Ok(FieldExprKind::Pow(exponent))
+}
+
+fn parse_lagrange(value: &str) -> Result<FieldExprKind, RustTargetPlanError> {
+    let spec = value
+        .strip_prefix("poly.lagrange_basis_eval:")
+        .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?;
+    let parts = spec.split(':').collect::<Vec<_>>();
+    let [domain_start, domain_size, index] = parts.as_slice() else {
+        return Err(RustTargetPlanError::unsupported(
+            "field expression formula",
+            value,
+        ));
+    };
+    let domain_start = domain_start
+        .parse::<i64>()
+        .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?;
+    let domain_size = domain_size
+        .parse::<usize>()
+        .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?;
+    let index = index
+        .parse::<usize>()
+        .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?;
+    Ok(FieldExprKind::LagrangeBasisEval {
+        domain_start,
+        domain_size,
+        index,
+    })
+}
+
+fn parse_lagrange_kernel(value: &str) -> Result<FieldExprKind, RustTargetPlanError> {
+    let spec = value
+        .strip_prefix("poly.lagrange_kernel_eval:")
+        .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?;
+    let parts = spec.split(':').collect::<Vec<_>>();
+    let [domain_start, domain_size] = parts.as_slice() else {
+        return Err(RustTargetPlanError::unsupported(
+            "field expression formula",
+            value,
+        ));
+    };
+    let domain_start = domain_start
+        .parse::<i64>()
+        .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?;
+    let domain_size = domain_size
+        .parse::<usize>()
+        .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?;
+    Ok(FieldExprKind::LagrangeKernelEval {
+        domain_start,
+        domain_size,
+    })
+}
+
+fn parse_power_strided_weighted_sum(value: &str) -> Result<ScalarExprKind, RustTargetPlanError> {
+    let spec = value
+        .strip_prefix("field.power_strided_weighted_sum:")
+        .ok_or_else(|| RustTargetPlanError::unsupported("scalar expression formula", value))?;
+    let parts = spec.split(':').collect::<Vec<_>>();
+    let [row_count, power_stride, value_offsets, shared_offsets, row_offsets] = parts.as_slice()
+    else {
+        return Err(RustTargetPlanError::unsupported(
+            "scalar expression formula",
+            value,
+        ));
+    };
+    let row_count = row_count
+        .parse::<usize>()
+        .map_err(|_| RustTargetPlanError::unsupported("scalar expression formula", value))?;
+    let power_stride = power_stride
+        .parse::<usize>()
+        .map_err(|_| RustTargetPlanError::unsupported("scalar expression formula", value))?;
+    Ok(ScalarExprKind::PowerStridedWeightedSum {
+        row_count,
+        power_stride,
+        value_term_offsets: parse_usize_list(value_offsets, value)?,
+        shared_term_offsets: parse_usize_list(shared_offsets, value)?,
+        row_term_offsets: parse_usize_list(row_offsets, value)?,
+    })
+}
+
+fn parse_point_element(value: &str) -> Result<ScalarExprKind, RustTargetPlanError> {
+    let index = value
+        .strip_prefix("point.element:")
+        .and_then(|index| index.parse::<usize>().ok())
+        .ok_or_else(|| RustTargetPlanError::unsupported("scalar expression formula", value))?;
+    Ok(ScalarExprKind::PointElement { index })
+}
+
+fn parse_structured_polynomial_scalar(value: &str) -> Result<ScalarExprKind, RustTargetPlanError> {
+    let spec = value
+        .strip_prefix("poly.structured_eval:")
+        .ok_or_else(|| RustTargetPlanError::unsupported("scalar expression formula", value))?;
+    let [polynomial, x_segment, x_length, x_order, y_segment, y_length, y_order] =
+        spec.split(':').collect::<Vec<_>>()[..]
+    else {
+        return Err(RustTargetPlanError::unsupported(
+            "scalar expression formula",
+            value,
+        ));
+    };
+    Ok(ScalarExprKind::StructuredPolynomial {
+        polynomial: StructuredPolynomialKind::from_attr(polynomial)?,
+        x_point: StructuredPolynomialPointTransform::new(x_segment, x_length, x_order)?,
+        y_point: StructuredPolynomialPointTransform::new(y_segment, y_length, y_order)?,
+    })
+}
+
+pub(crate) fn power_strided_weighted_sum_formula(
+    row_count: usize,
+    power_stride: usize,
+    value_term_offsets: &[usize],
+    shared_term_offsets: &[usize],
+    row_term_offsets: &[usize],
+) -> String {
+    format!(
+        "field.power_strided_weighted_sum:{row_count}:{power_stride}:{}:{}:{}",
+        join_usize_list(value_term_offsets),
+        join_usize_list(shared_term_offsets),
+        join_usize_list(row_term_offsets),
+    )
+}
+
+pub(crate) fn structured_polynomial_scalar_formula(
+    polynomial: &str,
+    x_segment: &str,
+    x_length: &str,
+    x_order: &str,
+    y_segment: &str,
+    y_length: &str,
+    y_order: &str,
+) -> String {
+    format!(
+        "poly.structured_eval:{polynomial}:{x_segment}:{x_length}:{x_order}:{y_segment}:{y_length}:{y_order}"
+    )
+}
+
+fn parse_usize_list(value: &str, full_formula: &str) -> Result<Vec<usize>, RustTargetPlanError> {
+    if value == "_" {
+        return Ok(Vec::new());
+    }
+    value
+        .split(',')
+        .map(|part| {
+            part.parse::<usize>().map_err(|_| {
+                RustTargetPlanError::unsupported("scalar expression formula", full_formula)
+            })
+        })
+        .collect()
+}
+
+fn join_usize_list(values: &[usize]) -> String {
+    if values.is_empty() {
+        return "_".to_owned();
+    }
+    values
+        .iter()
+        .map(usize::to_string)
+        .collect::<Vec<_>>()
+        .join(",")
+}
+
+fn usize_slice_expr(values: &[usize]) -> String {
+    if values.is_empty() {
+        return "&[]".to_owned();
+    }
+    let values = values
+        .iter()
+        .map(usize::to_string)
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("&[{values}]")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode,
+        ProgramStepKind, ScalarExprKind, StructuredPolynomialKind, StructuredPolynomialPointLength,
+        StructuredPolynomialPointOrder, StructuredPolynomialPointSegment,
+        StructuredPolynomialPointTransform, SumcheckPointOrder, TranscriptSqueezeKind,
+    };
+
+    #[test]
+    fn parses_typed_rust_target_ids_from_cpu_attrs() {
+        assert_eq!(
+            ProgramStepKind::from_cpu_attr("sumcheck_driver").ok(),
+            Some(ProgramStepKind::SumcheckDriver)
+        );
+        assert_eq!(
+            TranscriptSqueezeKind::from_cpu_attr("challenge_vector").ok(),
+            Some(TranscriptSqueezeKind::ChallengeVector)
+        );
+        assert_eq!(
+            ClaimKind::from_cpu_attr("virtual").ok(),
+            Some(ClaimKind::Virtual)
+        );
+        assert_eq!(
+            JoltVerifierRelationKind::from_cpu_attr("jolt.stage6.booleanity").ok(),
+            Some(JoltVerifierRelationKind::Stage6Booleanity)
+        );
+        assert_eq!(
+            PcsProofMode::from_cpu_attr("verify").ok(),
+            Some(PcsProofMode::Verify)
+        );
+        assert_eq!(
+            OpeningEqualityMode::from_cpu_attr("point_and_eval").ok(),
+            Some(OpeningEqualityMode::PointAndEval)
+        );
+        assert_eq!(
+            SumcheckPointOrder::from_cpu_attr("instruction_read_raf").ok(),
+            Some(SumcheckPointOrder::RelationLocal)
+        );
+        assert_eq!(
+            SumcheckPointOrder::from_cpu_attr("stage6_booleanity").ok(),
+            Some(SumcheckPointOrder::AsIs)
+        );
+    }
+
+    #[test]
+    fn parses_compound_field_expr_kinds() {
+        assert_eq!(
+            FieldExprKind::from_cpu_attr("field.pow:32").ok(),
+            Some(FieldExprKind::Pow(32))
+        );
+        assert_eq!(
+            FieldExprKind::from_cpu_attr("field.sum").ok(),
+            Some(FieldExprKind::Sum)
+        );
+        assert_eq!(
+            FieldExprKind::from_cpu_attr("field.product").ok(),
+            Some(FieldExprKind::Product)
+        );
+        assert_eq!(
+            FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:-1:3:2").ok(),
+            Some(FieldExprKind::LagrangeBasisEval {
+                domain_start: -1,
+                domain_size: 3,
+                index: 2,
+            })
+        );
+        assert_eq!(
+            FieldExprKind::from_cpu_attr("poly.lagrange_kernel_eval:-1:3").ok(),
+            Some(FieldExprKind::LagrangeKernelEval {
+                domain_start: -1,
+                domain_size: 3,
+            })
+        );
+        assert!(FieldExprKind::from_cpu_attr("field_vector.sum").is_err());
+        assert!(FieldExprKind::from_cpu_attr("field.pow:nope").is_err());
+        assert!(FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:1:2").is_err());
+        assert!(FieldExprKind::from_cpu_attr("poly.lagrange_kernel_eval:1").is_err());
+    }
+
+    #[test]
+    fn parses_scalar_expr_kinds() {
+        assert_eq!(
+            ScalarExprKind::from_cpu_attr("field_vector.sum").ok(),
+            Some(ScalarExprKind::FieldVectorSum)
+        );
+        assert_eq!(
+            ScalarExprKind::from_cpu_attr("field_vector.product").ok(),
+            Some(ScalarExprKind::FieldVectorProduct)
+        );
+        assert_eq!(
+            ScalarExprKind::from_cpu_attr("field.power_strided_weighted_sum:39:3:0:1:2").ok(),
+            Some(ScalarExprKind::PowerStridedWeightedSum {
+                row_count: 39,
+                power_stride: 3,
+                value_term_offsets: vec![0],
+                shared_term_offsets: vec![1],
+                row_term_offsets: vec![2],
+            })
+        );
+        assert_eq!(
+            ScalarExprKind::from_cpu_attr(
+                "poly.structured_eval:lt:suffix:y_point:reverse:full:full:as_is"
+            )
+            .ok(),
+            Some(ScalarExprKind::StructuredPolynomial {
+                polynomial: StructuredPolynomialKind::Lt,
+                x_point: StructuredPolynomialPointTransform {
+                    segment: StructuredPolynomialPointSegment::Suffix,
+                    length: StructuredPolynomialPointLength::YPoint,
+                    order: StructuredPolynomialPointOrder::Reverse,
+                },
+                y_point: StructuredPolynomialPointTransform {
+                    segment: StructuredPolynomialPointSegment::Full,
+                    length: StructuredPolynomialPointLength::Full,
+                    order: StructuredPolynomialPointOrder::AsIs,
+                },
+            })
+        );
+        assert_eq!(
+            ScalarExprKind::from_cpu_attr("point.element:0").ok(),
+            Some(ScalarExprKind::PointElement { index: 0 })
+        );
+        assert!(ScalarExprKind::from_cpu_attr("field.power_strided_weighted_sum:1:2:0").is_err());
+        assert!(ScalarExprKind::from_cpu_attr("poly.structured_eval:eq:full").is_err());
+        assert!(ScalarExprKind::from_cpu_attr("point.element:nope").is_err());
+    }
+
+    #[test]
+    fn emits_generated_rust_variant_names_without_cpu_attr_spelling() {
+        assert_eq!(
+            JoltVerifierRelationKind::Stage5RegistersValEvaluation.rust_variant(),
+            "Stage5RegistersValEvaluation"
+        );
+        assert_eq!(
+            FieldExprKind::LagrangeBasisEval {
+                domain_start: -1,
+                domain_size: 3,
+                index: 0,
+            }
+            .rust_variant_expr(),
+            "LagrangeBasisEval(-1, 3, 0)"
+        );
+        assert_eq!(
+            FieldExprKind::LagrangeKernelEval {
+                domain_start: -1,
+                domain_size: 3,
+            }
+            .rust_variant_expr(),
+            "LagrangeKernelEval(-1, 3)"
+        );
+        assert_eq!(
+            ScalarExprKind::PowerStridedWeightedSum {
+                row_count: 39,
+                power_stride: 3,
+                value_term_offsets: vec![0],
+                shared_term_offsets: vec![1],
+                row_term_offsets: vec![2],
+            }
+            .rust_variant_expr(),
+            "PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }"
+        );
+        assert_eq!(
+            ScalarExprKind::StructuredPolynomial {
+                polynomial: StructuredPolynomialKind::EqPlusOne,
+                x_point: StructuredPolynomialPointTransform {
+                    segment: StructuredPolynomialPointSegment::Prefix,
+                    length: StructuredPolynomialPointLength::YPoint,
+                    order: StructuredPolynomialPointOrder::Reverse,
+                },
+                y_point: StructuredPolynomialPointTransform {
+                    segment: StructuredPolynomialPointSegment::Full,
+                    length: StructuredPolynomialPointLength::Full,
+                    order: StructuredPolynomialPointOrder::AsIs,
+                },
+            }
+            .rust_variant_expr(),
+            "StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }"
+        );
+        assert_eq!(
+            ScalarExprKind::PointElement { index: 7 }.rust_variant_expr(),
+            "PointElement { index: 7 }"
+        );
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs
new file mode 100644
index 0000000000..7b4bd47338
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs
@@ -0,0 +1,489 @@
+use crate::emit::rust::{push_format, EmitError};
+use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind;
+use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan;
+use crate::protocols::jolt::verifier_local_scalars::{
+    emit_jolt_local_scalar_constants, JoltLocalScalarEmitPlan, JoltLocalScalarMleKind,
+};
+use crate::protocols::jolt::verifier_relation_outputs::{
+    RelationOutputPlan, StructuredPolynomialEvalPlan, StructuredPolynomialKind,
+    StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan,
+    StructuredPolynomialPointSegment,
+};
+use crate::protocols::jolt::verifier_values::VerifierPointValueRef;
+
+pub(crate) const STAGE5_TABLE_FLAG_EVAL_FAMILY: &str =
+    "stage5.instruction_read_raf.eval.LookupTableFlag";
+pub(crate) const STAGE5_INSTRUCTION_RA_EVAL_FAMILY: &str =
+    "stage5.instruction_read_raf.eval.InstructionRa";
+const STAGE5_INDEXED_EVAL_FAMILIES_CONST: &str = "STAGE5_INDEXED_EVAL_FAMILIES";
+const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS_CONST: &str =
+    "STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS";
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct Stage5InstructionReadRafEmitPlan {
+    pub(crate) point: String,
+    pub(crate) lookup_output_point: String,
+    pub(crate) table_flag_evals: IndexedEvalFamilyPlan,
+    pub(crate) table_flag_evals_ref: String,
+    pub(crate) instruction_ra_evals: IndexedEvalFamilyPlan,
+    pub(crate) instruction_ra_evals_ref: String,
+    pub(crate) raf_flag_eval: String,
+    pub(crate) gamma: String,
+    pub(crate) local_scalars: Vec<JoltLocalScalarEmitPlan>,
+    pub(crate) log_k: usize,
+}
+
+impl Stage5InstructionReadRafEmitPlan {
+    pub(crate) fn from_eval_families(
+        eval_families: &[IndexedEvalFamilyPlan],
+    ) -> Result<Self, EmitError> {
+        let (table_flag_evals_index, table_flag_evals) =
+            IndexedEvalFamilyPlan::find_with_index(eval_families, STAGE5_TABLE_FLAG_EVAL_FAMILY)?;
+        let (instruction_ra_evals_index, instruction_ra_evals) =
+            IndexedEvalFamilyPlan::find_with_index(
+                eval_families,
+                STAGE5_INSTRUCTION_RA_EVAL_FAMILY,
+            )?;
+        Ok(Self {
+            point: "stage5.instruction_read_raf.instance".to_owned(),
+            lookup_output_point: "stage5.input.stage2.instruction.LookupOutput".to_owned(),
+            local_scalars: local_scalar_plans(table_flag_evals.evals.len()),
+            table_flag_evals: table_flag_evals.clone(),
+            table_flag_evals_ref: indexed_eval_family_ref(table_flag_evals_index),
+            instruction_ra_evals: instruction_ra_evals.clone(),
+            instruction_ra_evals_ref: indexed_eval_family_ref(instruction_ra_evals_index),
+            raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag".to_owned(),
+            gamma: "stage5.instruction_read_raf.gamma".to_owned(),
+            log_k: 128,
+        })
+    }
+
+    pub(crate) fn emit_runtime_constants(&self) -> String {
+        let mut source = String::new();
+        source.push_str(&emit_jolt_local_scalar_constants(
+            STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS_CONST,
+            &self.local_scalars,
+        ));
+        push_format(
+            &mut source,
+            format_args!(
+                "pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan {{\n\
+                 \x20   point: {},\n\
+                 \x20   lookup_output_point: {},\n\
+                 \x20   table_flag_evals: {},\n\
+                 \x20   instruction_ra_evals: {},\n\
+                 \x20   raf_flag_eval: {},\n\
+                 \x20   gamma: {},\n\
+                 \x20   local_scalars: STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS,\n\
+                 \x20   log_k: {},\n\
+                 }};\n\n",
+                rust_str(&self.point),
+                rust_str(&self.lookup_output_point),
+                self.table_flag_evals_ref,
+                self.instruction_ra_evals_ref,
+                rust_str(&self.raf_flag_eval),
+                rust_str(&self.gamma),
+                self.log_k,
+            ),
+        );
+        source
+    }
+
+    pub(crate) fn relation_output_plan(&self) -> Stage5InstructionReadRafOutputPlan {
+        const PREFIX: &str = "stage5.instruction_read_raf.output";
+
+        let eq = StructuredPolynomialEvalPlan {
+            symbol: format!("{PREFIX}.eq.LookupOutputCycle"),
+            polynomial: StructuredPolynomialKind::Eq,
+            x_point: StructuredPolynomialPointPlan {
+                source: VerifierPointValueRef::new(self.point.clone()),
+                segment: StructuredPolynomialPointSegment::Suffix,
+                length: StructuredPolynomialPointLength::YPoint,
+                order: StructuredPolynomialPointOrder::Reverse,
+            },
+            y_point: StructuredPolynomialPointPlan {
+                source: VerifierPointValueRef::new(self.lookup_output_point.clone()),
+                segment: StructuredPolynomialPointSegment::Full,
+                length: StructuredPolynomialPointLength::Full,
+                order: StructuredPolynomialPointOrder::AsIs,
+            },
+        };
+
+        let left = "stage5.instruction_read_raf.local_scalar.LeftLookupOperand".to_owned();
+        let right = "stage5.instruction_read_raf.local_scalar.RightLookupOperand".to_owned();
+        let identity = "stage5.instruction_read_raf.local_scalar.Identity".to_owned();
+        let gamma_right = format!("{PREFIX}.term.GammaRightLookupOperand");
+        let left_plus_gamma_right = format!("{PREFIX}.partial.LeftPlusGammaRight");
+        let raf_flag_left_plus_gamma_right = format!("{PREFIX}.term.RafFlagLeftPlusGammaRight");
+        let non_raf_lookup_operands = format!("{PREFIX}.partial.NonRafLookupOperands");
+        let gamma_identity = format!("{PREFIX}.term.GammaIdentity");
+        let raf_flag_gamma_identity = format!("{PREFIX}.term.RafFlagGammaIdentity");
+        let raf_claim = format!("{PREFIX}.partial.RafClaim");
+        let gamma_raf_claim = format!("{PREFIX}.term.GammaRafClaim");
+        let table_values = format!("{PREFIX}.product.LookupTableValues");
+        let instruction_ra_product = format!("{PREFIX}.product.InstructionRa");
+        let lookup_or_raf = format!("{PREFIX}.partial.LookupOrRaf");
+        let eq_ra = format!("{PREFIX}.partial.EqRa");
+        let claim_expr = format!("{PREFIX}.claim_expr");
+
+        let mut field_exprs =
+            Vec::with_capacity(self.table_flag_evals.evals.len().saturating_add(12));
+        let mut table_value_terms = Vec::with_capacity(self.table_flag_evals.evals.len());
+        for (index, (flag_eval, table_value)) in self
+            .table_flag_evals
+            .evals
+            .iter()
+            .zip(
+                self.local_scalars
+                    .iter()
+                    .filter(|value| value.is_lookup_table()),
+            )
+            .enumerate()
+        {
+            let term = format!("{PREFIX}.term.LookupTableValue_{index}");
+            table_value_terms.push(term.clone());
+            field_exprs.push(output_field_expr(
+                term,
+                "field.mul",
+                vec![table_value.symbol.clone(), flag_eval.clone()],
+            ));
+        }
+        field_exprs.extend([
+            output_field_expr(table_values.clone(), "field.sum", table_value_terms),
+            output_field_expr(
+                instruction_ra_product.clone(),
+                "field_vector.product",
+                vec![self.instruction_ra_evals.symbol.clone()],
+            ),
+            output_field_expr(
+                gamma_right.clone(),
+                "field.mul",
+                vec![self.gamma.clone(), right],
+            ),
+            output_field_expr(
+                left_plus_gamma_right.clone(),
+                "field.add",
+                vec![left, gamma_right],
+            ),
+            output_field_expr(
+                raf_flag_left_plus_gamma_right.clone(),
+                "field.mul",
+                vec![self.raf_flag_eval.clone(), left_plus_gamma_right.clone()],
+            ),
+            output_field_expr(
+                non_raf_lookup_operands.clone(),
+                "field.sub",
+                vec![left_plus_gamma_right, raf_flag_left_plus_gamma_right],
+            ),
+            output_field_expr(
+                gamma_identity.clone(),
+                "field.mul",
+                vec![self.gamma.clone(), identity],
+            ),
+            output_field_expr(
+                raf_flag_gamma_identity.clone(),
+                "field.mul",
+                vec![self.raf_flag_eval.clone(), gamma_identity],
+            ),
+            output_field_expr(
+                raf_claim.clone(),
+                "field.add",
+                vec![non_raf_lookup_operands, raf_flag_gamma_identity],
+            ),
+            output_field_expr(
+                gamma_raf_claim.clone(),
+                "field.mul",
+                vec![self.gamma.clone(), raf_claim],
+            ),
+            output_field_expr(
+                lookup_or_raf.clone(),
+                "field.add",
+                vec![table_values, gamma_raf_claim],
+            ),
+            output_field_expr(
+                eq_ra.clone(),
+                "field.mul",
+                vec![eq.symbol.clone(), instruction_ra_product],
+            ),
+            output_field_expr(claim_expr.clone(), "field.mul", vec![eq_ra, lookup_or_raf]),
+        ]);
+
+        Stage5InstructionReadRafOutputPlan {
+            relation_output_values: vec![eq.clone()],
+            field_exprs,
+            claim: RelationOutputPlan::with_local_scalars(
+                JoltVerifierRelationKind::Stage5InstructionReadRaf,
+                self.local_scalars.iter().map(|value| value.symbol.clone()),
+                claim_expr,
+            ),
+        }
+    }
+
+    pub(crate) fn local_scalar_symbols(&self) -> impl Iterator<Item = &String> {
+        self.local_scalars.iter().map(|value| &value.symbol)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct Stage5InstructionReadRafOutputPlan {
+    pub(crate) relation_output_values: Vec<StructuredPolynomialEvalPlan>,
+    pub(crate) field_exprs: Vec<Stage5InstructionReadRafOutputFieldExprPlan>,
+    pub(crate) claim: RelationOutputPlan,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct Stage5InstructionReadRafOutputFieldExprPlan {
+    pub(crate) symbol: String,
+    pub(crate) formula: String,
+    pub(crate) operands: Vec<String>,
+}
+
+fn local_scalar_plans(table_count: usize) -> Vec<JoltLocalScalarEmitPlan> {
+    let mut values = (0..table_count)
+        .map(|index| JoltLocalScalarEmitPlan {
+            symbol: format!("stage5.instruction_read_raf.local_scalar.LookupTable_{index}"),
+            kind: JoltLocalScalarMleKind::LookupTable { index },
+        })
+        .collect::<Vec<_>>();
+    values.extend([
+        JoltLocalScalarEmitPlan {
+            symbol: "stage5.instruction_read_raf.local_scalar.LeftLookupOperand".to_owned(),
+            kind: JoltLocalScalarMleKind::LeftOperand,
+        },
+        JoltLocalScalarEmitPlan {
+            symbol: "stage5.instruction_read_raf.local_scalar.RightLookupOperand".to_owned(),
+            kind: JoltLocalScalarMleKind::RightOperand,
+        },
+        JoltLocalScalarEmitPlan {
+            symbol: "stage5.instruction_read_raf.local_scalar.Identity".to_owned(),
+            kind: JoltLocalScalarMleKind::Identity,
+        },
+    ]);
+    values
+}
+
+fn output_field_expr(
+    symbol: String,
+    formula: &str,
+    operands: Vec<String>,
+) -> Stage5InstructionReadRafOutputFieldExprPlan {
+    Stage5InstructionReadRafOutputFieldExprPlan {
+        symbol,
+        formula: formula.to_owned(),
+        operands,
+    }
+}
+
+fn rust_str(value: &str) -> String {
+    format!("{value:?}")
+}
+
+fn indexed_eval_family_ref(index: usize) -> String {
+    format!("&{STAGE5_INDEXED_EVAL_FAMILIES_CONST}[{index}]")
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::emit::rust::EmitError;
+    use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind;
+    use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan;
+
+    use super::{
+        Stage5InstructionReadRafEmitPlan, STAGE5_INSTRUCTION_RA_EVAL_FAMILY,
+        STAGE5_TABLE_FLAG_EVAL_FAMILY,
+    };
+
+    #[test]
+    fn instruction_read_raf_plan_groups_indexed_eval_families() -> Result<(), EmitError> {
+        let families = instruction_read_raf_families([
+            (
+                "LookupTableFlag_1",
+                "stage5.instruction_read_raf.eval.LookupTableFlag_1",
+            ),
+            (
+                "InstructionRafFlag",
+                "stage5.instruction_read_raf.eval.InstructionRafFlag",
+            ),
+            (
+                "InstructionRa_0",
+                "stage5.instruction_read_raf.eval.InstructionRa_0",
+            ),
+            (
+                "LookupTableFlag_0",
+                "stage5.instruction_read_raf.eval.LookupTableFlag_0",
+            ),
+        ]);
+        let plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)?;
+
+        assert_eq!(
+            plan.table_flag_evals.evals,
+            vec![
+                "stage5.instruction_read_raf.eval.LookupTableFlag_0",
+                "stage5.instruction_read_raf.eval.LookupTableFlag_1"
+            ]
+        );
+        assert_eq!(
+            plan.instruction_ra_evals.evals,
+            vec!["stage5.instruction_read_raf.eval.InstructionRa_0"]
+        );
+        assert_eq!(
+            plan.table_flag_evals_ref,
+            "&STAGE5_INDEXED_EVAL_FAMILIES[0]"
+        );
+        assert_eq!(
+            plan.instruction_ra_evals_ref,
+            "&STAGE5_INDEXED_EVAL_FAMILIES[1]"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn instruction_read_raf_plan_references_indexed_eval_family_rows() -> Result<(), EmitError> {
+        let families = instruction_read_raf_families([
+            (
+                "LookupTableFlag_0",
+                "stage5.instruction_read_raf.eval.LookupTableFlag_0",
+            ),
+            (
+                "InstructionRa_0",
+                "stage5.instruction_read_raf.eval.InstructionRa_0",
+            ),
+        ]);
+        let plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)?;
+        let source = plan.emit_runtime_constants();
+
+        assert!(!source.contains("STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS"));
+        assert!(!source.contains("STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS"));
+        assert!(source.contains("table_flag_evals: &STAGE5_INDEXED_EVAL_FAMILIES[0]"));
+        assert!(source.contains("instruction_ra_evals: &STAGE5_INDEXED_EVAL_FAMILIES[1]"));
+        Ok(())
+    }
+
+    #[test]
+    fn instruction_read_raf_relation_output_plan_is_typed() -> Result<(), EmitError> {
+        let families = instruction_read_raf_families([
+            (
+                "LookupTableFlag_0",
+                "stage5.instruction_read_raf.eval.LookupTableFlag_0",
+            ),
+            (
+                "LookupTableFlag_1",
+                "stage5.instruction_read_raf.eval.LookupTableFlag_1",
+            ),
+            (
+                "InstructionRa_0",
+                "stage5.instruction_read_raf.eval.InstructionRa_0",
+            ),
+        ]);
+        let plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)?;
+        let output_plan = plan.relation_output_plan();
+
+        assert_eq!(
+            output_plan.claim.relation(),
+            JoltVerifierRelationKind::Stage5InstructionReadRaf
+        );
+        assert_eq!(
+            output_plan.claim.expected_output_symbol(),
+            "stage5.instruction_read_raf.output.claim_expr"
+        );
+        assert_eq!(output_plan.relation_output_values.len(), 1);
+        assert_eq!(
+            output_plan.relation_output_values[0].symbol,
+            "stage5.instruction_read_raf.output.eq.LookupOutputCycle"
+        );
+        assert_eq!(
+            output_plan
+                .claim
+                .local_scalar_symbols()
+                .cloned()
+                .collect::<Vec<_>>(),
+            vec![
+                "stage5.instruction_read_raf.local_scalar.LookupTable_0".to_owned(),
+                "stage5.instruction_read_raf.local_scalar.LookupTable_1".to_owned(),
+                "stage5.instruction_read_raf.local_scalar.LeftLookupOperand".to_owned(),
+                "stage5.instruction_read_raf.local_scalar.RightLookupOperand".to_owned(),
+                "stage5.instruction_read_raf.local_scalar.Identity".to_owned(),
+            ]
+        );
+        assert!(output_plan.field_exprs.iter().any(|expr| {
+            expr.symbol == "stage5.instruction_read_raf.output.term.LookupTableValue_0"
+                && expr.formula == "field.mul"
+                && expr.operands
+                    == vec![
+                        "stage5.instruction_read_raf.local_scalar.LookupTable_0".to_owned(),
+                        "stage5.instruction_read_raf.eval.LookupTableFlag_0".to_owned(),
+                    ]
+        }));
+        assert!(output_plan.field_exprs.iter().any(|expr| {
+            expr.symbol == "stage5.instruction_read_raf.output.product.LookupTableValues"
+                && expr.formula == "field.sum"
+                && expr.operands
+                    == vec![
+                        "stage5.instruction_read_raf.output.term.LookupTableValue_0".to_owned(),
+                        "stage5.instruction_read_raf.output.term.LookupTableValue_1".to_owned(),
+                    ]
+        }));
+        assert!(output_plan.field_exprs.iter().any(|expr| {
+            expr.symbol == "stage5.instruction_read_raf.output.product.InstructionRa"
+                && expr.formula == "field_vector.product"
+                && expr.operands == vec![STAGE5_INSTRUCTION_RA_EVAL_FAMILY.to_owned()]
+        }));
+        assert!(output_plan.field_exprs.iter().any(|expr| {
+            expr.symbol == "stage5.instruction_read_raf.output.claim_expr"
+                && expr.formula == "field.mul"
+                && expr.operands
+                    == vec![
+                        "stage5.instruction_read_raf.output.partial.EqRa".to_owned(),
+                        "stage5.instruction_read_raf.output.partial.LookupOrRaf".to_owned(),
+                    ]
+        }));
+        Ok(())
+    }
+
+    #[test]
+    fn instruction_read_raf_plan_requires_explicit_eval_family_rows() {
+        let families = [IndexedEvalFamilyPlan {
+            symbol: STAGE5_TABLE_FLAG_EVAL_FAMILY.to_owned(),
+            evals: vec!["stage5.instruction_read_raf.eval.LookupTableFlag_0".to_owned()],
+        }];
+
+        let error = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)
+            .err()
+            .map(|error| error.to_string())
+            .unwrap_or_default();
+
+        assert!(
+            error.contains("missing eval family `stage5.instruction_read_raf.eval.InstructionRa`")
+        );
+    }
+
+    fn instruction_read_raf_families<'a>(
+        evals: impl IntoIterator<Item = (&'a str, &'a str)>,
+    ) -> Vec<IndexedEvalFamilyPlan> {
+        let evals = evals.into_iter().collect::<Vec<_>>();
+        vec![
+            IndexedEvalFamilyPlan {
+                symbol: STAGE5_TABLE_FLAG_EVAL_FAMILY.to_owned(),
+                evals: indexed_names("LookupTableFlag_", &evals),
+            },
+            IndexedEvalFamilyPlan {
+                symbol: STAGE5_INSTRUCTION_RA_EVAL_FAMILY.to_owned(),
+                evals: indexed_names("InstructionRa_", &evals),
+            },
+        ]
+    }
+
+    fn indexed_names(prefix: &str, evals: &[(&str, &str)]) -> Vec<String> {
+        let mut names = evals
+            .iter()
+            .filter_map(|(oracle, name)| {
+                oracle
+                    .strip_prefix(prefix)
+                    .and_then(|index| index.parse::<usize>().ok())
+                    .map(|index| (index, (*name).to_owned()))
+            })
+            .collect::<Vec<_>>();
+        names.sort_by_key(|(index, _)| *index);
+        names.into_iter().map(|(_, name)| name).collect()
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs
new file mode 100644
index 0000000000..fa38295e95
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs
@@ -0,0 +1,844 @@
+use crate::emit::rust::{push_format, EmitError};
+use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind;
+use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan;
+use crate::protocols::jolt::verifier_relation_outputs::{
+    RelationOutputFieldExprPlan, RelationOutputPlan,
+};
+
+pub(crate) const STAGE6_BYTECODE_RA_EVAL_FAMILY: &str = "stage6.bytecode_read_raf.eval.BytecodeRa";
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct BytecodeReadRafPlan {
+    pub(crate) const_name: &'static str,
+    pub(crate) point: &'static str,
+    pub(crate) gamma: &'static str,
+    pub(crate) entries: &'static str,
+    pub(crate) entry_bytecode_index: &'static str,
+    pub(crate) stages_const: &'static str,
+    pub(crate) stages: &'static [BytecodeReadRafStagePlan],
+    pub(crate) output_terms_const: &'static str,
+    pub(crate) output_terms: &'static [BytecodeOutputTermPlan],
+    pub(crate) output_contribution: &'static str,
+    pub(crate) registers: BytecodeRegisterSymbols,
+    pub(crate) entry_lookup_table: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct BytecodeReadRafStagePlan {
+    pub(crate) terms_const: &'static str,
+    pub(crate) gamma: &'static str,
+    pub(crate) cycle_point: &'static str,
+    pub(crate) register_point: Option<&'static str>,
+    pub(crate) terms: &'static [BytecodeReadRafTermPlan],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum BytecodeOutputTermPlan {
+    StageValue {
+        symbol: &'static str,
+        stage_index: usize,
+        gamma_power: usize,
+        identity_gamma_power: Option<usize>,
+    },
+    Entry {
+        symbol: &'static str,
+        gamma_power: usize,
+    },
+}
+
+impl BytecodeOutputTermPlan {
+    fn symbol(self) -> &'static str {
+        match self {
+            Self::StageValue { symbol, .. } | Self::Entry { symbol, .. } => symbol,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct BytecodeRegisterSymbols {
+    pub(crate) rd: &'static str,
+    pub(crate) rs1: &'static str,
+    pub(crate) rs2: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum BytecodeReadRafTermPlan {
+    Address {
+        gamma_power: usize,
+    },
+    Imm {
+        gamma_power: usize,
+    },
+    CircuitFlag {
+        index: usize,
+        gamma_power: usize,
+    },
+    EntryFlag {
+        flag: BytecodeFlag,
+        expected: bool,
+        gamma_power: usize,
+    },
+    RegisterEq {
+        register: BytecodeRegister,
+        gamma_power: usize,
+    },
+    LookupTable {
+        gamma_base: usize,
+    },
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum BytecodeFlag {
+    IsInterleaved,
+    IsBranch,
+    LeftIsRs1,
+    LeftIsPc,
+    RightIsRs2,
+    RightIsImm,
+    IsNoop,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum BytecodeRegister {
+    Rd,
+    Rs1,
+    Rs2,
+}
+
+const STAGE6_BYTECODE_STAGE1_TERMS: &[BytecodeReadRafTermPlan] = &[
+    BytecodeReadRafTermPlan::Address { gamma_power: 0 },
+    BytecodeReadRafTermPlan::Imm { gamma_power: 1 },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 0,
+        gamma_power: 2,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 1,
+        gamma_power: 3,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 2,
+        gamma_power: 4,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 3,
+        gamma_power: 5,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 4,
+        gamma_power: 6,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 5,
+        gamma_power: 7,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 6,
+        gamma_power: 8,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 7,
+        gamma_power: 9,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 8,
+        gamma_power: 10,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 9,
+        gamma_power: 11,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 10,
+        gamma_power: 12,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 11,
+        gamma_power: 13,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 12,
+        gamma_power: 14,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 13,
+        gamma_power: 15,
+    },
+];
+
+const STAGE6_BYTECODE_STAGE2_TERMS: &[BytecodeReadRafTermPlan] = &[
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 5,
+        gamma_power: 0,
+    },
+    BytecodeReadRafTermPlan::EntryFlag {
+        flag: BytecodeFlag::IsBranch,
+        expected: true,
+        gamma_power: 1,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 6,
+        gamma_power: 2,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 7,
+        gamma_power: 3,
+    },
+];
+
+const STAGE6_BYTECODE_STAGE3_TERMS: &[BytecodeReadRafTermPlan] = &[
+    BytecodeReadRafTermPlan::Imm { gamma_power: 0 },
+    BytecodeReadRafTermPlan::Address { gamma_power: 1 },
+    BytecodeReadRafTermPlan::EntryFlag {
+        flag: BytecodeFlag::LeftIsRs1,
+        expected: true,
+        gamma_power: 2,
+    },
+    BytecodeReadRafTermPlan::EntryFlag {
+        flag: BytecodeFlag::LeftIsPc,
+        expected: true,
+        gamma_power: 3,
+    },
+    BytecodeReadRafTermPlan::EntryFlag {
+        flag: BytecodeFlag::RightIsRs2,
+        expected: true,
+        gamma_power: 4,
+    },
+    BytecodeReadRafTermPlan::EntryFlag {
+        flag: BytecodeFlag::RightIsImm,
+        expected: true,
+        gamma_power: 5,
+    },
+    BytecodeReadRafTermPlan::EntryFlag {
+        flag: BytecodeFlag::IsNoop,
+        expected: true,
+        gamma_power: 6,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 7,
+        gamma_power: 7,
+    },
+    BytecodeReadRafTermPlan::CircuitFlag {
+        index: 12,
+        gamma_power: 8,
+    },
+];
+
+const STAGE6_BYTECODE_STAGE4_TERMS: &[BytecodeReadRafTermPlan] = &[
+    BytecodeReadRafTermPlan::RegisterEq {
+        register: BytecodeRegister::Rd,
+        gamma_power: 0,
+    },
+    BytecodeReadRafTermPlan::RegisterEq {
+        register: BytecodeRegister::Rs1,
+        gamma_power: 1,
+    },
+    BytecodeReadRafTermPlan::RegisterEq {
+        register: BytecodeRegister::Rs2,
+        gamma_power: 2,
+    },
+];
+
+const STAGE6_BYTECODE_STAGE5_TERMS: &[BytecodeReadRafTermPlan] = &[
+    BytecodeReadRafTermPlan::RegisterEq {
+        register: BytecodeRegister::Rd,
+        gamma_power: 0,
+    },
+    BytecodeReadRafTermPlan::EntryFlag {
+        flag: BytecodeFlag::IsInterleaved,
+        expected: false,
+        gamma_power: 1,
+    },
+    BytecodeReadRafTermPlan::LookupTable { gamma_base: 2 },
+];
+
+const STAGE6_BYTECODE_STAGES: &[BytecodeReadRafStagePlan] = &[
+    BytecodeReadRafStagePlan {
+        terms_const: "STAGE6_BYTECODE_STAGE1_TERMS",
+        gamma: "stage6.bytecode_read_raf.stage1_gamma",
+        cycle_point: "stage6.input.stage1.Imm",
+        register_point: None,
+        terms: STAGE6_BYTECODE_STAGE1_TERMS,
+    },
+    BytecodeReadRafStagePlan {
+        terms_const: "STAGE6_BYTECODE_STAGE2_TERMS",
+        gamma: "stage6.bytecode_read_raf.stage2_gamma",
+        cycle_point: "stage6.input.stage2.OpFlagJump",
+        register_point: None,
+        terms: STAGE6_BYTECODE_STAGE2_TERMS,
+    },
+    BytecodeReadRafStagePlan {
+        terms_const: "STAGE6_BYTECODE_STAGE3_TERMS",
+        gamma: "stage6.bytecode_read_raf.stage3_gamma",
+        cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC",
+        register_point: None,
+        terms: STAGE6_BYTECODE_STAGE3_TERMS,
+    },
+    BytecodeReadRafStagePlan {
+        terms_const: "STAGE6_BYTECODE_STAGE4_TERMS",
+        gamma: "stage6.bytecode_read_raf.stage4_gamma",
+        cycle_point: "stage6.input.stage4.Rs1Ra",
+        register_point: Some("stage6.input.stage4.Rs1Ra"),
+        terms: STAGE6_BYTECODE_STAGE4_TERMS,
+    },
+    BytecodeReadRafStagePlan {
+        terms_const: "STAGE6_BYTECODE_STAGE5_TERMS",
+        gamma: "stage6.bytecode_read_raf.stage5_gamma",
+        cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa",
+        register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"),
+        terms: STAGE6_BYTECODE_STAGE5_TERMS,
+    },
+];
+
+const STAGE6_BYTECODE_OUTPUT_TERMS: &[BytecodeOutputTermPlan] = &[
+    BytecodeOutputTermPlan::StageValue {
+        symbol: "stage6.bytecode_read_raf.output.term.Stage1",
+        stage_index: 0,
+        gamma_power: 0,
+        identity_gamma_power: Some(5),
+    },
+    BytecodeOutputTermPlan::StageValue {
+        symbol: "stage6.bytecode_read_raf.output.term.Stage2",
+        stage_index: 1,
+        gamma_power: 1,
+        identity_gamma_power: None,
+    },
+    BytecodeOutputTermPlan::StageValue {
+        symbol: "stage6.bytecode_read_raf.output.term.Stage3",
+        stage_index: 2,
+        gamma_power: 2,
+        identity_gamma_power: Some(4),
+    },
+    BytecodeOutputTermPlan::StageValue {
+        symbol: "stage6.bytecode_read_raf.output.term.Stage4",
+        stage_index: 3,
+        gamma_power: 3,
+        identity_gamma_power: None,
+    },
+    BytecodeOutputTermPlan::StageValue {
+        symbol: "stage6.bytecode_read_raf.output.term.Stage5",
+        stage_index: 4,
+        gamma_power: 4,
+        identity_gamma_power: None,
+    },
+    BytecodeOutputTermPlan::Entry {
+        symbol: "stage6.bytecode_read_raf.output.term.Entry",
+        gamma_power: 7,
+    },
+];
+
+const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan {
+    const_name: "STAGE6_BYTECODE_PLAN",
+    point: "stage6.bytecode_read_raf.point",
+    gamma: "stage6.bytecode_read_raf.gamma",
+    entries: "stage6.bytecode_read_raf.entries",
+    entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index",
+    stages_const: "STAGE6_BYTECODE_STAGES",
+    stages: STAGE6_BYTECODE_STAGES,
+    output_terms_const: "STAGE6_BYTECODE_OUTPUT_TERMS",
+    output_terms: STAGE6_BYTECODE_OUTPUT_TERMS,
+    output_contribution: "stage6.bytecode_read_raf.output.contribution",
+    registers: BytecodeRegisterSymbols {
+        rd: "stage6.bytecode.entry.rd",
+        rs1: "stage6.bytecode.entry.rs1",
+        rs2: "stage6.bytecode.entry.rs2",
+    },
+    entry_lookup_table: "stage6.bytecode.entry.lookup_table",
+};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct Stage6BytecodeReadRafEmitPlan {
+    pub(crate) bytecode_ra_evals: IndexedEvalFamilyPlan,
+    pub(crate) bytecode_ra_evals_ref: String,
+}
+
+impl Stage6BytecodeReadRafEmitPlan {
+    pub(crate) fn from_eval_families(
+        eval_families: &[IndexedEvalFamilyPlan],
+    ) -> Result<Self, EmitError> {
+        let (bytecode_ra_evals_ref, bytecode_ra_evals) = stage6_bytecode_read_raf_eval_family_ref(
+            eval_families,
+            "STAGE6_INDEXED_EVAL_FAMILIES",
+        )?;
+        Ok(Self {
+            bytecode_ra_evals: bytecode_ra_evals.clone(),
+            bytecode_ra_evals_ref,
+        })
+    }
+
+    pub(crate) fn emit_runtime_constants(&self) -> String {
+        emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN, &self.bytecode_ra_evals_ref)
+    }
+
+    pub(crate) fn relation_output_plan(&self) -> Stage6BytecodeReadRafRelationOutputPlan {
+        STAGE6_BYTECODE_READ_RAF_PLAN.relation_output_plan(&self.bytecode_ra_evals)
+    }
+
+    pub(crate) fn local_scalar_symbols() -> impl Iterator<Item = &'static str> {
+        STAGE6_BYTECODE_READ_RAF_PLAN
+            .output_terms
+            .iter()
+            .copied()
+            .map(BytecodeOutputTermPlan::symbol)
+    }
+}
+
+#[cfg(test)]
+pub(crate) fn stage6_bytecode_read_raf_output_contribution_symbol() -> &'static str {
+    STAGE6_BYTECODE_READ_RAF_PLAN.output_contribution
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct Stage6BytecodeReadRafRelationOutputPlan {
+    pub(crate) field_exprs: Vec<RelationOutputFieldExprPlan>,
+    pub(crate) claim: RelationOutputPlan,
+}
+
+impl BytecodeReadRafPlan {
+    fn relation_output_plan(
+        &self,
+        bytecode_ra_evals: &IndexedEvalFamilyPlan,
+    ) -> Stage6BytecodeReadRafRelationOutputPlan {
+        let bytecode_ra_product = "stage6.bytecode_read_raf.output.product.BytecodeRa".to_owned();
+        let claim_expr = "stage6.bytecode_read_raf.output.claim_expr".to_owned();
+        let output_term_symbols = self
+            .output_terms
+            .iter()
+            .copied()
+            .map(BytecodeOutputTermPlan::symbol)
+            .map(str::to_owned)
+            .collect::<Vec<_>>();
+        Stage6BytecodeReadRafRelationOutputPlan {
+            field_exprs: vec![
+                RelationOutputFieldExprPlan {
+                    symbol: bytecode_ra_product.clone(),
+                    formula: "field_vector.product".to_owned(),
+                    operands: vec![bytecode_ra_evals.symbol.clone()],
+                },
+                RelationOutputFieldExprPlan {
+                    symbol: self.output_contribution.to_owned(),
+                    formula: "field.sum".to_owned(),
+                    operands: output_term_symbols.clone(),
+                },
+                RelationOutputFieldExprPlan {
+                    symbol: claim_expr.clone(),
+                    formula: "field.product".to_owned(),
+                    operands: vec![self.output_contribution.to_owned(), bytecode_ra_product],
+                },
+            ],
+            claim: RelationOutputPlan::with_local_scalars(
+                JoltVerifierRelationKind::Stage6BytecodeReadRaf,
+                output_term_symbols,
+                claim_expr,
+            ),
+        }
+    }
+}
+
+fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan, bytecode_ra_evals_ref: &str) -> String {
+    let mut source = "\n".to_owned();
+
+    for stage in plan.stages {
+        push_format(
+            &mut source,
+            format_args!(
+                "const {}: &[Stage67BytecodeTermPlan] = &[\n",
+                stage.terms_const
+            ),
+        );
+        for term in stage.terms {
+            push_format(
+                &mut source,
+                format_args!("    {},\n", emit_bytecode_read_raf_term_plan(term)),
+            );
+        }
+        source.push_str("];\n");
+    }
+
+    push_format(
+        &mut source,
+        format_args!(
+            "const {}: &[Stage67BytecodeStagePlan] = &[\n",
+            plan.stages_const
+        ),
+    );
+    for stage in plan.stages {
+        push_format(
+            &mut source,
+            format_args!(
+                "    Stage67BytecodeStagePlan {{ gamma: {}, cycle_point: {}, register_point: {}, terms: {} }},\n",
+                rust_str(stage.gamma),
+                rust_str(stage.cycle_point),
+                rust_option_str(stage.register_point),
+                stage.terms_const,
+            ),
+        );
+    }
+    source.push_str("];\n\n");
+
+    push_format(
+        &mut source,
+        format_args!(
+            "const {}: &[Stage67BytecodeOutputTermPlan] = &[\n",
+            plan.output_terms_const
+        ),
+    );
+    for term in plan.output_terms {
+        push_format(
+            &mut source,
+            format_args!("    {},\n", emit_bytecode_output_term_plan(term)),
+        );
+    }
+    source.push_str("];\n\n");
+
+    push_format(
+        &mut source,
+        format_args!(
+            "pub const {}: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan {{\n",
+            plan.const_name
+        ),
+    );
+    push_format(
+        &mut source,
+        format_args!(
+            "    point: {},\n    gamma: {},\n    bytecode_ra_evals: &{},\n    entries: {},\n    entry_bytecode_index: {},\n    stages: {},\n    output_terms: {},\n    output_contribution: {},\n",
+            rust_str(plan.point),
+            rust_str(plan.gamma),
+            bytecode_ra_evals_ref,
+            rust_str(plan.entries),
+            rust_str(plan.entry_bytecode_index),
+            plan.stages_const,
+            plan.output_terms_const,
+            rust_str(plan.output_contribution),
+        ),
+    );
+    source.push_str("    registers: Stage67BytecodeRegisterSymbols {\n");
+    push_format(
+        &mut source,
+        format_args!(
+            "        rd: {},\n        rs1: {},\n        rs2: {},\n",
+            rust_str(plan.registers.rd),
+            rust_str(plan.registers.rs1),
+            rust_str(plan.registers.rs2),
+        ),
+    );
+    source.push_str("    },\n");
+    push_format(
+        &mut source,
+        format_args!(
+            "    entry_lookup_table: {},\n",
+            rust_str(plan.entry_lookup_table)
+        ),
+    );
+    source.push_str("};\n");
+    source
+}
+
+fn stage6_bytecode_read_raf_eval_family_ref<'a>(
+    eval_families: &'a [IndexedEvalFamilyPlan],
+    families_const: &str,
+) -> Result<(String, &'a IndexedEvalFamilyPlan), EmitError> {
+    let (index, family) =
+        IndexedEvalFamilyPlan::find_with_index(eval_families, STAGE6_BYTECODE_RA_EVAL_FAMILY)?;
+    Ok((format!("{families_const}[{index}]"), family))
+}
+
+fn emit_bytecode_read_raf_term_plan(term: &BytecodeReadRafTermPlan) -> String {
+    match term {
+        BytecodeReadRafTermPlan::Address { gamma_power } => {
+            format!("Stage67BytecodeTermPlan::Address {{ gamma_power: {gamma_power} }}")
+        }
+        BytecodeReadRafTermPlan::Imm { gamma_power } => {
+            format!("Stage67BytecodeTermPlan::Imm {{ gamma_power: {gamma_power} }}")
+        }
+        BytecodeReadRafTermPlan::CircuitFlag { index, gamma_power } => format!(
+            "Stage67BytecodeTermPlan::CircuitFlag {{ index: {index}, gamma_power: {gamma_power} }}"
+        ),
+        BytecodeReadRafTermPlan::EntryFlag {
+            flag,
+            expected,
+            gamma_power,
+        } => format!(
+            "Stage67BytecodeTermPlan::EntryFlag {{ flag: {}, expected: {expected}, gamma_power: {gamma_power} }}",
+            emit_bytecode_flag(*flag)
+        ),
+        BytecodeReadRafTermPlan::RegisterEq {
+            register,
+            gamma_power,
+        } => format!(
+            "Stage67BytecodeTermPlan::RegisterEq {{ register: {}, gamma_power: {gamma_power} }}",
+            emit_bytecode_register(*register)
+        ),
+        BytecodeReadRafTermPlan::LookupTable { gamma_base } => {
+            format!("Stage67BytecodeTermPlan::LookupTable {{ gamma_base: {gamma_base} }}")
+        }
+    }
+}
+
+fn emit_bytecode_output_term_plan(term: &BytecodeOutputTermPlan) -> String {
+    match *term {
+        BytecodeOutputTermPlan::StageValue {
+            symbol,
+            stage_index,
+            gamma_power,
+            identity_gamma_power,
+        } => format!(
+            "Stage67BytecodeOutputTermPlan::StageValue {{ symbol: {}, stage_index: {stage_index}, gamma_power: {gamma_power}, identity_gamma_power: {} }}",
+            rust_str(symbol),
+            emit_option_usize(identity_gamma_power),
+        ),
+        BytecodeOutputTermPlan::Entry {
+            symbol,
+            gamma_power,
+        } => {
+            format!(
+                "Stage67BytecodeOutputTermPlan::Entry {{ symbol: {}, gamma_power: {gamma_power} }}",
+                rust_str(symbol)
+            )
+        }
+    }
+}
+
+fn emit_bytecode_flag(flag: BytecodeFlag) -> &'static str {
+    match flag {
+        BytecodeFlag::IsInterleaved => "Stage67BytecodeFlag::IsInterleaved",
+        BytecodeFlag::IsBranch => "Stage67BytecodeFlag::IsBranch",
+        BytecodeFlag::LeftIsRs1 => "Stage67BytecodeFlag::LeftIsRs1",
+        BytecodeFlag::LeftIsPc => "Stage67BytecodeFlag::LeftIsPc",
+        BytecodeFlag::RightIsRs2 => "Stage67BytecodeFlag::RightIsRs2",
+        BytecodeFlag::RightIsImm => "Stage67BytecodeFlag::RightIsImm",
+        BytecodeFlag::IsNoop => "Stage67BytecodeFlag::IsNoop",
+    }
+}
+
+fn emit_bytecode_register(register: BytecodeRegister) -> &'static str {
+    match register {
+        BytecodeRegister::Rd => "Stage67BytecodeRegister::Rd",
+        BytecodeRegister::Rs1 => "Stage67BytecodeRegister::Rs1",
+        BytecodeRegister::Rs2 => "Stage67BytecodeRegister::Rs2",
+    }
+}
+
+fn emit_option_usize(value: Option<usize>) -> String {
+    value.map_or_else(|| "None".to_owned(), |value| format!("Some({value})"))
+}
+
+fn rust_str(value: &str) -> String {
+    format!("{value:?}")
+}
+
+fn rust_option_str(value: Option<&str>) -> String {
+    value.map_or_else(
+        || "None".to_owned(),
+        |value| format!("Some({})", rust_str(value)),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::emit::rust::EmitError;
+    use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind;
+    use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan;
+
+    use super::{
+        stage6_bytecode_read_raf_output_contribution_symbol, BytecodeFlag, BytecodeOutputTermPlan,
+        BytecodeReadRafTermPlan, BytecodeRegister, Stage6BytecodeReadRafEmitPlan,
+        STAGE6_BYTECODE_RA_EVAL_FAMILY, STAGE6_BYTECODE_READ_RAF_PLAN,
+    };
+
+    fn bytecode_ra_evals() -> IndexedEvalFamilyPlan {
+        IndexedEvalFamilyPlan {
+            symbol: "stage6.bytecode_read_raf.eval.BytecodeRa".to_owned(),
+            evals: (0..4)
+                .map(|index| format!("stage6.bytecode_read_raf.eval.BytecodeRa_{index}"))
+                .collect(),
+        }
+    }
+
+    #[test]
+    fn stage6_bytecode_plan_rows_encode_the_read_raf_reduction() {
+        let plan = &STAGE6_BYTECODE_READ_RAF_PLAN;
+
+        assert_eq!(plan.stages.len(), 5);
+        assert_eq!(plan.output_terms.len(), 6);
+        assert_eq!(plan.registers.rd, "stage6.bytecode.entry.rd");
+        assert_eq!(
+            plan.entry_lookup_table,
+            "stage6.bytecode.entry.lookup_table"
+        );
+        assert_eq!(
+            plan.output_contribution,
+            "stage6.bytecode_read_raf.output.contribution"
+        );
+
+        let stage1 = &plan.stages[0];
+        assert_eq!(stage1.terms.len(), 16);
+        assert_eq!(
+            plan.output_terms[0],
+            BytecodeOutputTermPlan::StageValue {
+                symbol: "stage6.bytecode_read_raf.output.term.Stage1",
+                stage_index: 0,
+                gamma_power: 0,
+                identity_gamma_power: Some(5),
+            }
+        );
+        assert_eq!(
+            plan.output_terms[5],
+            BytecodeOutputTermPlan::Entry {
+                symbol: "stage6.bytecode_read_raf.output.term.Entry",
+                gamma_power: 7
+            }
+        );
+        assert_eq!(
+            stage1.terms[0],
+            BytecodeReadRafTermPlan::Address { gamma_power: 0 }
+        );
+        assert_eq!(
+            stage1.terms[1],
+            BytecodeReadRafTermPlan::Imm { gamma_power: 1 }
+        );
+        for (index, term) in stage1.terms[2..].iter().enumerate() {
+            assert_eq!(
+                *term,
+                BytecodeReadRafTermPlan::CircuitFlag {
+                    index,
+                    gamma_power: index + 2,
+                }
+            );
+        }
+
+        assert_eq!(
+            plan.stages[1].terms[1],
+            BytecodeReadRafTermPlan::EntryFlag {
+                flag: BytecodeFlag::IsBranch,
+                expected: true,
+                gamma_power: 1,
+            }
+        );
+        assert_eq!(
+            plan.stages[3].terms,
+            &[
+                BytecodeReadRafTermPlan::RegisterEq {
+                    register: BytecodeRegister::Rd,
+                    gamma_power: 0,
+                },
+                BytecodeReadRafTermPlan::RegisterEq {
+                    register: BytecodeRegister::Rs1,
+                    gamma_power: 1,
+                },
+                BytecodeReadRafTermPlan::RegisterEq {
+                    register: BytecodeRegister::Rs2,
+                    gamma_power: 2,
+                },
+            ]
+        );
+        assert_eq!(
+            plan.stages[4].terms,
+            &[
+                BytecodeReadRafTermPlan::RegisterEq {
+                    register: BytecodeRegister::Rd,
+                    gamma_power: 0,
+                },
+                BytecodeReadRafTermPlan::EntryFlag {
+                    flag: BytecodeFlag::IsInterleaved,
+                    expected: false,
+                    gamma_power: 1,
+                },
+                BytecodeReadRafTermPlan::LookupTable { gamma_base: 2 },
+            ]
+        );
+    }
+
+    #[test]
+    fn stage6_bytecode_relation_output_plan_uses_point_derived_contribution(
+    ) -> Result<(), EmitError> {
+        let output_plan =
+            Stage6BytecodeReadRafEmitPlan::from_eval_families(&[bytecode_ra_evals()])?
+                .relation_output_plan();
+        let claim = output_plan.claim;
+
+        assert_eq!(
+            claim.relation(),
+            JoltVerifierRelationKind::Stage6BytecodeReadRaf
+        );
+        assert_eq!(
+            claim.expected_output_symbol(),
+            "stage6.bytecode_read_raf.output.claim_expr"
+        );
+        assert_eq!(
+            claim.local_scalar_symbols().cloned().collect::<Vec<_>>(),
+            vec![
+                "stage6.bytecode_read_raf.output.term.Stage1".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Stage2".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Stage3".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Stage4".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Stage5".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Entry".to_owned(),
+            ]
+        );
+        assert_eq!(output_plan.field_exprs[0].formula, "field_vector.product");
+        assert_eq!(
+            output_plan.field_exprs[0].operands,
+            vec![STAGE6_BYTECODE_RA_EVAL_FAMILY.to_owned()]
+        );
+        assert_eq!(output_plan.field_exprs[1].formula, "field.sum");
+        assert_eq!(
+            output_plan.field_exprs[1].operands,
+            vec![
+                "stage6.bytecode_read_raf.output.term.Stage1".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Stage2".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Stage3".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Stage4".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Stage5".to_owned(),
+                "stage6.bytecode_read_raf.output.term.Entry".to_owned(),
+            ]
+        );
+        assert_eq!(output_plan.field_exprs[2].formula, "field.product");
+        assert_eq!(
+            output_plan.field_exprs[2].operands,
+            vec![
+                stage6_bytecode_read_raf_output_contribution_symbol().to_owned(),
+                "stage6.bytecode_read_raf.output.product.BytecodeRa".to_owned()
+            ]
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn stage6_bytecode_plan_renderer_emits_stage67_constants() -> Result<(), EmitError> {
+        let source = Stage6BytecodeReadRafEmitPlan::from_eval_families(&[bytecode_ra_evals()])?
+            .emit_runtime_constants();
+
+        assert!(source.contains("const STAGE6_BYTECODE_STAGE1_TERMS"));
+        assert!(source.contains("Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }"));
+        assert!(source.contains("Stage67BytecodeFlag::IsInterleaved"));
+        assert!(source.contains("Stage67BytecodeRegister::Rs2"));
+        assert!(!source.contains("STAGE6_BYTECODE_RA_EVAL_NAMES"));
+        assert!(!source.contains("STAGE6_BYTECODE_RA_EVALS"));
+        assert!(source.contains("const STAGE6_BYTECODE_OUTPUT_TERMS"));
+        assert!(source.contains(
+            "Stage67BytecodeOutputTermPlan::Entry { symbol: \"stage6.bytecode_read_raf.output.term.Entry\", gamma_power: 7 }"
+        ));
+        assert!(source
+            .contains("output_contribution: \"stage6.bytecode_read_raf.output.contribution\""));
+        assert!(source.contains("bytecode_ra_evals: &STAGE6_INDEXED_EVAL_FAMILIES[0]"));
+        assert!(source.contains("pub const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan"));
+        Ok(())
+    }
+
+    #[test]
+    fn stage6_bytecode_plan_references_indexed_eval_family_row() -> Result<(), EmitError> {
+        let families = [bytecode_ra_evals()];
+        let plan = Stage6BytecodeReadRafEmitPlan::from_eval_families(&families)?;
+
+        assert_eq!(
+            plan.bytecode_ra_evals_ref,
+            "STAGE6_INDEXED_EVAL_FAMILIES[0]"
+        );
+        assert_eq!(
+            plan.bytecode_ra_evals.symbol,
+            STAGE6_BYTECODE_RA_EVAL_FAMILY
+        );
+        Ok(())
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt/src/protocols/jolt/verifier_common.rs.template
deleted file mode 100644
index 493e9e9395..0000000000
--- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template
+++ /dev/null
@@ -1,1789 +0,0 @@
-#![expect(
-    clippy::too_many_arguments,
-    reason = "generated verifier helpers mirror staged protocol ABIs"
-)]
-
-use jolt_field::{Field, Fr, MulPow2, RingCore};
-use jolt_poly::EqPolynomial;
-use jolt_sumcheck::{
-    CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier,
-};
-use jolt_transcript::{Label, Transcript};
-use serde::Serialize;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageParams {
-    pub field: &'static str,
-    pub pcs: &'static str,
-    pub transcript: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct KernelPlan {
-    pub symbol: &'static str,
-    pub relation: &'static str,
-    pub kind: &'static str,
-    pub backend: &'static str,
-    pub abi: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct TranscriptSqueezePlan {
-    pub symbol: &'static str,
-    pub label: &'static str,
-    pub kind: &'static str,
-    pub count: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct TranscriptAbsorbBytesPlan {
-    pub symbol: &'static str,
-    pub label: &'static str,
-    pub payload: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct ProgramStepPlan {
-    pub kind: &'static str,
-    pub symbol: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct OpeningInputPlan {
-    pub symbol: &'static str,
-    pub source_stage: &'static str,
-    pub source_claim: &'static str,
-    pub oracle: &'static str,
-    pub domain: &'static str,
-    pub point_arity: usize,
-    pub claim_kind: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct FieldConstantPlan {
-    pub symbol: &'static str,
-    pub field: &'static str,
-    pub value: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct FieldExprPlan {
-    pub symbol: &'static str,
-    pub kind: &'static str,
-    pub formula: &'static str,
-    pub operands: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckClaimPlan {
-    pub symbol: &'static str,
-    pub stage: &'static str,
-    pub domain: &'static str,
-    pub num_rounds: usize,
-    pub degree: usize,
-    pub claim: &'static str,
-    pub kernel: Option<&'static str>,
-    pub relation: Option<&'static str>,
-    pub claim_value: &'static str,
-    pub input_openings: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckBatchPlan {
-    pub symbol: &'static str,
-    pub stage: &'static str,
-    pub proof_slot: &'static str,
-    pub policy: &'static str,
-    pub count: usize,
-    pub ordered_claims: &'static str,
-    pub claim_operands: &'static str,
-    pub claim_label: &'static str,
-    pub round_label: &'static str,
-    pub round_schedule: &'static [usize],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckDriverPlan {
-    pub symbol: &'static str,
-    pub stage: &'static str,
-    pub proof_slot: &'static str,
-    pub kernel: Option<&'static str>,
-    pub relation: Option<&'static str>,
-    pub batch: &'static str,
-    pub policy: &'static str,
-    pub round_schedule: &'static [usize],
-    pub claim_label: &'static str,
-    pub round_label: &'static str,
-    pub num_rounds: usize,
-    pub degree: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckInstanceResultPlan {
-    pub symbol: &'static str,
-    pub source: &'static str,
-    pub claim: &'static str,
-    pub relation: &'static str,
-    pub index: usize,
-    pub point_arity: usize,
-    pub num_rounds: usize,
-    pub round_offset: usize,
-    pub point_order: &'static str,
-    pub degree: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckEvalPlan {
-    pub symbol: &'static str,
-    pub source: &'static str,
-    pub name: &'static str,
-    pub index: usize,
-    pub oracle: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct PointZeroPlan {
-    pub symbol: &'static str,
-    pub field: &'static str,
-    pub arity: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct PointSlicePlan {
-    pub symbol: &'static str,
-    pub source: &'static str,
-    pub offset: usize,
-    pub length: usize,
-    pub input: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct PointConcatPlan {
-    pub symbol: &'static str,
-    pub layout: &'static str,
-    pub arity: usize,
-    pub inputs: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct OpeningClaimPlan {
-    pub symbol: &'static str,
-    pub oracle: &'static str,
-    pub domain: &'static str,
-    pub point_arity: usize,
-    pub claim_kind: &'static str,
-    pub point_source: &'static str,
-    pub eval_source: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct OpeningClaimEqualityPlan {
-    pub symbol: &'static str,
-    pub mode: &'static str,
-    pub lhs: &'static str,
-    pub rhs: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct OpeningBatchPlan {
-    pub symbol: &'static str,
-    pub stage: &'static str,
-    pub proof_slot: &'static str,
-    pub policy: &'static str,
-    pub count: usize,
-    pub ordered_claims: &'static str,
-    pub claim_operands: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageProgramPlan {
-    pub role: &'static str,
-    pub params: StageParams,
-    pub steps: &'static [ProgramStepPlan],
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub transcript_absorb_bytes: &'static [TranscriptAbsorbBytesPlan],
-    pub opening_inputs: &'static [OpeningInputPlan],
-    pub field_constants: &'static [FieldConstantPlan],
-    pub field_exprs: &'static [FieldExprPlan],
-    pub kernels: &'static [KernelPlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub point_zeros: &'static [PointZeroPlan],
-    pub point_slices: &'static [PointSlicePlan],
-    pub point_concats: &'static [PointConcatPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_equalities: &'static [OpeningClaimEqualityPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageProgramPlanNoPointZeros {
-    pub role: &'static str,
-    pub params: StageParams,
-    pub steps: &'static [ProgramStepPlan],
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub transcript_absorb_bytes: &'static [TranscriptAbsorbBytesPlan],
-    pub opening_inputs: &'static [OpeningInputPlan],
-    pub field_constants: &'static [FieldConstantPlan],
-    pub field_exprs: &'static [FieldExprPlan],
-    pub kernels: &'static [KernelPlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub point_slices: &'static [PointSlicePlan],
-    pub point_concats: &'static [PointConcatPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_equalities: &'static [OpeningClaimEqualityPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageVerifierProgramPlan {
-    pub params: StageParams,
-    pub steps: &'static [ProgramStepPlan],
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub opening_inputs: &'static [OpeningInputPlan],
-    pub field_constants: &'static [FieldConstantPlan],
-    pub field_exprs: &'static [FieldExprPlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub point_slices: &'static [PointSlicePlan],
-    pub point_concats: &'static [PointConcatPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_equalities: &'static [OpeningClaimEqualityPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageVerifierProgramPlanNoEqualities {
-    pub params: StageParams,
-    pub steps: &'static [ProgramStepPlan],
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub opening_inputs: &'static [OpeningInputPlan],
-    pub field_constants: &'static [FieldConstantPlan],
-    pub field_exprs: &'static [FieldExprPlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub point_slices: &'static [PointSlicePlan],
-    pub point_concats: &'static [PointConcatPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct VerifierProgramPlanMinimal {
-    pub params: StageParams,
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
-pub struct StageNamedEval<F: Field> {
-    pub name: &'static str,
-    pub oracle: &'static str,
-    pub value: F,
-}
-
-#[derive(Clone, Debug, Serialize)]
-pub struct StageSumcheckOutput<F: Field> {
-    pub driver: &'static str,
-    pub point: Vec<F>,
-    pub evals: Vec<StageNamedEval<F>>,
-    pub proof: SumcheckProof<F>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct StageChallengeVector<F: Field> {
-    pub symbol: &'static str,
-    pub values: Vec<F>,
-}
-
-#[derive(Clone, Debug)]
-pub struct StageExecutionArtifacts<F: Field> {
-    pub challenge_vectors: Vec<StageChallengeVector<F>>,
-    pub sumchecks: Vec<StageSumcheckOutput<F>>,
-    pub opening_batches: Vec<&'static OpeningBatchPlan>,
-}
-
-impl<F: Field> Default for StageExecutionArtifacts<F> {
-    fn default() -> Self {
-        Self {
-            challenge_vectors: Vec::new(),
-            sumchecks: Vec::new(),
-            opening_batches: Vec::new(),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct StageProof<F: Field> {
-    pub sumchecks: Vec<StageSumcheckOutput<F>>,
-}
-
-#[derive(Clone, Debug)]
-pub struct StageOpeningInputValue<F: Field> {
-    pub symbol: &'static str,
-    pub point: Vec<F>,
-    pub eval: F,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum RuntimePlanError {
-    MissingBatch {
-        driver: &'static str,
-        batch: &'static str,
-    },
-    MissingClaim {
-        batch: &'static str,
-        claim: &'static str,
-    },
-    MissingValue {
-        symbol: &'static str,
-    },
-    InvalidInputLength {
-        input: &'static str,
-        expected: usize,
-        actual: usize,
-    },
-    InvalidProof {
-        driver: &'static str,
-        reason: &'static str,
-    },
-    UnsupportedFieldExpr {
-        symbol: &'static str,
-        formula: &'static str,
-    },
-}
-
-macro_rules! impl_runtime_plan_error_conversion {
-    ($error:ident) => {
-        impl From<super::common::RuntimePlanError> for $error {
-            fn from(error: super::common::RuntimePlanError) -> Self {
-                match error {
-                    super::common::RuntimePlanError::MissingBatch { driver, batch } => {
-                        Self::MissingBatch { driver, batch }
-                    }
-                    super::common::RuntimePlanError::MissingClaim { batch, claim } => {
-                        Self::MissingClaim { batch, claim }
-                    }
-                    super::common::RuntimePlanError::MissingValue { symbol } => {
-                        Self::MissingValue { symbol }
-                    }
-                    super::common::RuntimePlanError::InvalidInputLength {
-                        input,
-                        expected,
-                        actual,
-                    } => Self::InvalidInputLength {
-                        input,
-                        expected,
-                        actual,
-                    },
-                    super::common::RuntimePlanError::InvalidProof { driver, reason } => {
-                        Self::InvalidProof { driver, reason }
-                    }
-                    super::common::RuntimePlanError::UnsupportedFieldExpr { symbol, formula } => {
-                        Self::UnsupportedFieldExpr { symbol, formula }
-                    }
-                }
-            }
-        }
-    };
-}
-
-pub(crate) use impl_runtime_plan_error_conversion;
-
-pub trait SymbolPlan {
-    fn symbol(&self) -> &'static str;
-}
-
-impl SymbolPlan for TranscriptSqueezePlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for TranscriptAbsorbBytesPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for SumcheckBatchPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for SumcheckClaimPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for SumcheckDriverPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for OpeningClaimPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-pub trait SumcheckClaimInfo: SymbolPlan {
-    fn num_rounds(&self) -> usize;
-    fn claim_value(&self) -> &'static str;
-}
-
-impl SumcheckClaimInfo for SumcheckClaimPlan {
-    fn num_rounds(&self) -> usize {
-        self.num_rounds
-    }
-
-    fn claim_value(&self) -> &'static str {
-        self.claim_value
-    }
-}
-
-pub trait SumcheckDriverInfo: SymbolPlan {
-    fn batch(&self) -> &'static str;
-    fn num_rounds(&self) -> usize;
-    fn degree(&self) -> usize;
-    fn round_label(&self) -> &'static str;
-}
-
-impl SumcheckDriverInfo for SumcheckDriverPlan {
-    fn batch(&self) -> &'static str {
-        self.batch
-    }
-
-    fn num_rounds(&self) -> usize {
-        self.num_rounds
-    }
-
-    fn degree(&self) -> usize {
-        self.degree
-    }
-
-    fn round_label(&self) -> &'static str {
-        self.round_label
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct ValueStore<F: Field> {
-    scalars: Vec<(&'static str, F)>,
-    points: Vec<(&'static str, Vec<F>)>,
-}
-
-impl<F: Field> ValueStore<F> {
-    pub fn with_opening_inputs(
-        inputs: &[StageOpeningInputValue<F>],
-        expected_inputs: &[OpeningInputPlan],
-    ) -> Result<Self, RuntimePlanError> {
-        if inputs.len() != expected_inputs.len() {
-            return Err(RuntimePlanError::InvalidInputLength {
-                input: "opening_inputs",
-                expected: expected_inputs.len(),
-                actual: inputs.len(),
-            });
-        }
-        for expected in expected_inputs {
-            let matching_count = inputs
-                .iter()
-                .filter(|input| input.symbol == expected.symbol)
-                .count();
-            if matching_count != 1 {
-                return Err(RuntimePlanError::InvalidInputLength {
-                    input: expected.symbol,
-                    expected: 1,
-                    actual: matching_count,
-                });
-            }
-            if let Some(input) = inputs.iter().find(|input| input.symbol == expected.symbol) {
-                if input.point.len() != expected.point_arity {
-                    return Err(RuntimePlanError::InvalidInputLength {
-                        input: expected.symbol,
-                        expected: expected.point_arity,
-                        actual: input.point.len(),
-                    });
-                }
-            }
-        }
-        let mut store = Self::default();
-        for input in inputs {
-            store.insert_scalar(input.symbol, input.eval);
-            store.insert_point(input.symbol, input.point.clone());
-        }
-        Ok(store)
-    }
-
-    pub fn seed_constants(&mut self, constants: &[FieldConstantPlan]) {
-        for constant in constants {
-            self.insert_scalar(constant.symbol, F::from_u64(constant.value as u64));
-        }
-    }
-
-    pub fn seed_point_zeros(&mut self, point_zeros: &[PointZeroPlan]) {
-        for zero in point_zeros {
-            self.insert_point(zero.symbol, vec![F::from_u64(0); zero.arity]);
-        }
-    }
-
-    pub fn observe_challenge_vector<E>(
-        &mut self,
-        plan: &TranscriptSqueezePlan,
-        values: &[F],
-        invalid_input_length: impl Fn(&'static str, usize, usize) -> E,
-    ) -> Result<(), E> {
-        self.insert_point(plan.symbol, values.to_vec());
-        if matches!(plan.kind, "challenge_scalar" | "scalar") {
-            if values.len() != 1 {
-                return Err(invalid_input_length(plan.symbol, 1, values.len()));
-            }
-            self.insert_scalar(plan.symbol, values[0]);
-        }
-        Ok(())
-    }
-
-    pub fn observe_sumcheck_output<E>(
-        &mut self,
-        instance_results: &[SumcheckInstanceResultPlan],
-        evals: &[SumcheckEvalPlan],
-        output: &StageSumcheckOutput<F>,
-        normalize_point: impl Fn(&SumcheckInstanceResultPlan, Vec<F>) -> Result<Vec<F>, E>,
-        invalid_input_length: impl Fn(&'static str, usize, usize) -> E,
-        missing_value: impl Fn(&'static str) -> E,
-    ) -> Result<(), E> {
-        self.insert_point(output.driver, output.point.clone());
-        for instance in instance_results
-            .iter()
-            .filter(|instance| instance.source == output.driver)
-        {
-            let end = instance.round_offset + instance.point_arity;
-            let point = output
-                .point
-                .get(instance.round_offset..end)
-                .ok_or_else(|| invalid_input_length(instance.symbol, end, output.point.len()))?
-                .to_vec();
-            self.insert_point(instance.symbol, normalize_point(instance, point)?);
-        }
-        for eval in evals.iter().filter(|eval| eval.source == output.driver) {
-            let value = output
-                .evals
-                .iter()
-                .find(|value| value.name == eval.name)
-                .or_else(|| output.evals.get(eval.index))
-                .ok_or_else(|| missing_value(eval.symbol))?
-                .value;
-            self.insert_scalar(eval.symbol, value);
-            self.insert_scalar(eval.name, value);
-        }
-        Ok(())
-    }
-
-    pub fn evaluate_available_points<E>(
-        &mut self,
-        point_slices: &[PointSlicePlan],
-        point_concats: &[PointConcatPlan],
-        invalid_input_length: impl Fn(&'static str, usize, usize) -> E,
-    ) -> Result<(), E> {
-        loop {
-            let mut progress = 0usize;
-            for slice in point_slices {
-                if self.try_point(slice.symbol).is_some() {
-                    continue;
-                }
-                let Some(input) = self.try_point(slice.input) else {
-                    continue;
-                };
-                let end = slice.offset + slice.length;
-                let point = input
-                    .get(slice.offset..end)
-                    .ok_or_else(|| invalid_input_length(slice.symbol, end, input.len()))?
-                    .to_vec();
-                self.insert_point(slice.symbol, point);
-                progress += 1;
-            }
-            for concat in point_concats {
-                if self.try_point(concat.symbol).is_some() {
-                    continue;
-                }
-                let Some(point) = self.try_concat_point(concat) else {
-                    continue;
-                };
-                if point.len() != concat.arity {
-                    return Err(invalid_input_length(
-                        concat.symbol,
-                        concat.arity,
-                        point.len(),
-                    ));
-                }
-                self.insert_point(concat.symbol, point);
-                progress += 1;
-            }
-            if progress == 0 {
-                return Ok(());
-            }
-        }
-    }
-
-    pub fn evaluate_available_field_exprs<E>(
-        &mut self,
-        field_exprs: &[FieldExprPlan],
-        evaluate: impl Fn(&FieldExprPlan, &[F]) -> Result<F, E>,
-    ) -> Result<(), E> {
-        loop {
-            let mut progress = 0usize;
-            for expr in field_exprs {
-                if self.try_scalar(expr.symbol).is_some() {
-                    continue;
-                }
-                let Some(operands) = self.try_expr_operands(expr) else {
-                    continue;
-                };
-                self.insert_scalar(expr.symbol, evaluate(expr, &operands)?);
-                progress += 1;
-            }
-            if progress == 0 {
-                return Ok(());
-            }
-        }
-    }
-
-    pub fn verify_opening_equalities<E>(
-        &self,
-        opening_equalities: &[OpeningClaimEqualityPlan],
-        invalid_proof: impl Fn(&'static str, &'static str) -> E,
-        missing_value: impl Fn(&'static str) -> E,
-    ) -> Result<(), E> {
-        for equality in opening_equalities {
-            match equality.mode {
-                "point_and_eval" => {
-                    if self.point_or(equality.lhs, &missing_value)?
-                        != self.point_or(equality.rhs, &missing_value)?
-                        || self.scalar_or(equality.lhs, &missing_value)?
-                            != self.scalar_or(equality.rhs, &missing_value)?
-                    {
-                        return Err(invalid_proof(
-                            equality.symbol,
-                            "opening claim equality failed",
-                        ));
-                    }
-                }
-                _ => {
-                    return Err(invalid_proof(
-                        equality.symbol,
-                        "unsupported opening equality mode",
-                    ));
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub fn insert_scalar(&mut self, symbol: &'static str, value: F) {
-        if let Some((_, existing)) = self.scalars.iter_mut().find(|(name, _)| *name == symbol) {
-            *existing = value;
-        } else {
-            self.scalars.push((symbol, value));
-        }
-    }
-
-    pub fn insert_point(&mut self, symbol: &'static str, point: Vec<F>) {
-        if let Some((_, existing)) = self.points.iter_mut().find(|(name, _)| *name == symbol) {
-            *existing = point;
-        } else {
-            self.points.push((symbol, point));
-        }
-    }
-
-    pub fn scalar_or<E>(
-        &self,
-        symbol: &'static str,
-        missing_value: impl FnOnce(&'static str) -> E,
-    ) -> Result<F, E> {
-        self.try_scalar(symbol).ok_or_else(|| missing_value(symbol))
-    }
-
-    pub fn try_scalar(&self, symbol: &str) -> Option<F> {
-        self.scalars
-            .iter()
-            .find(|(name, _)| *name == symbol)
-            .map(|(_, value)| *value)
-    }
-
-    pub fn point_or<E>(
-        &self,
-        symbol: &'static str,
-        missing_value: impl FnOnce(&'static str) -> E,
-    ) -> Result<&[F], E> {
-        self.try_point(symbol).ok_or_else(|| missing_value(symbol))
-    }
-
-    pub fn try_point(&self, symbol: &str) -> Option<&[F]> {
-        self.points
-            .iter()
-            .find(|(name, _)| *name == symbol)
-            .map(|(_, point)| point.as_slice())
-    }
-
-    fn try_expr_operands(&self, expr: &FieldExprPlan) -> Option<Vec<F>> {
-        if expr.operands.is_empty() {
-            return Some(Vec::new());
-        }
-        expr.operands
-            .split('|')
-            .map(|operand| self.try_scalar(operand))
-            .collect()
-    }
-
-    fn try_concat_point(&self, concat: &PointConcatPlan) -> Option<Vec<F>> {
-        let mut point = Vec::with_capacity(concat.arity);
-        for input in symbol_list(concat.inputs) {
-            point.extend_from_slice(self.try_point(input)?);
-        }
-        Some(point)
-    }
-}
-
-pub fn symbol_list(symbols: &'static str) -> impl Iterator<Item = &'static str> {
-    symbols.split('|').filter(|symbol| !symbol.is_empty())
-}
-
-pub fn find_plan<'a, T: SymbolPlan>(plans: &'a [T], symbol: &str) -> Option<&'a T> {
-    plans.iter().find(|plan| plan.symbol() == symbol)
-}
-
-pub fn find_batch<'a>(
-    batches: &'a [SumcheckBatchPlan],
-    driver: &'static str,
-    batch: &'static str,
-) -> Result<&'a SumcheckBatchPlan, RuntimePlanError> {
-    find_plan(batches, batch).ok_or(RuntimePlanError::MissingBatch { driver, batch })
-}
-
-pub fn batch_claims<'a, C: SymbolPlan>(
-    claims: &'a [C],
-    batch: &SumcheckBatchPlan,
-) -> Result<Vec<&'a C>, RuntimePlanError> {
-    symbol_list(batch.claim_operands)
-        .map(|symbol| {
-            find_plan(claims, symbol).ok_or(RuntimePlanError::MissingClaim {
-                batch: batch.symbol,
-                claim: symbol,
-            })
-        })
-        .collect()
-}
-
-pub fn batch_claim_values<C: SumcheckClaimInfo>(
-    claims: &[&C],
-    field_exprs: &[FieldExprPlan],
-    store: &mut ValueStore<Fr>,
-) -> Result<Vec<Fr>, RuntimePlanError> {
-    claims
-        .iter()
-        .map(|claim| {
-            store.evaluate_available_field_exprs(field_exprs, evaluate_field_expr)?;
-            store.scalar_or(claim.claim_value(), |symbol| {
-                RuntimePlanError::MissingValue { symbol }
-            })
-        })
-        .collect()
-}
-
-pub fn verify_batched_sumcheck<T, E, C, D, Expected, Observe, MapSumcheck>(
-    driver: &'static D,
-    proof: &StageSumcheckOutput<Fr>,
-    claims: &'static [C],
-    batches: &'static [SumcheckBatchPlan],
-    field_exprs: &'static [FieldExprPlan],
-    opening_inputs: &'static [OpeningInputPlan],
-    opening_claims: &'static [OpeningClaimPlan],
-    opening_batches: &'static [OpeningBatchPlan],
-    store: &mut ValueStore<Fr>,
-    transcript: &mut T,
-    expected_output: Expected,
-    observe_output: Observe,
-    map_sumcheck: MapSumcheck,
-) -> Result<StageSumcheckOutput<Fr>, E>
-where
-    T: Transcript<Challenge = Fr>,
-    E: From<RuntimePlanError>,
-    C: SumcheckClaimInfo,
-    D: SumcheckDriverInfo,
-    Expected: FnOnce(&ValueStore<Fr>, &[StageNamedEval<Fr>], &[Fr], &[Fr]) -> Result<Fr, E>,
-    Observe: FnOnce(&mut ValueStore<Fr>, &StageSumcheckOutput<Fr>) -> Result<(), E>,
-    MapSumcheck: FnOnce(&'static str, SumcheckError<Fr>) -> E,
-{
-    if proof.driver != driver.symbol() {
-        return Err(RuntimePlanError::InvalidProof {
-            driver: driver.symbol(),
-            reason: "driver symbol mismatch",
-        }
-        .into());
-    }
-    let batch = find_batch(batches, driver.symbol(), driver.batch())?;
-    let claims = batch_claims(claims, batch)?;
-    let input_claims = batch_claim_values(&claims, field_exprs, store)?;
-    for claim in &input_claims {
-        append_labeled_scalar(transcript, batch.claim_label, claim);
-    }
-    let batching_coeffs = transcript.challenge_vector(claims.len());
-    let claimed_sum = input_claims
-        .iter()
-        .zip(claims.iter())
-        .zip(&batching_coeffs)
-        .map(|((claim, plan), coefficient)| {
-            claim.mul_pow_2(driver.num_rounds() - plan.num_rounds()) * *coefficient
-        })
-        .sum::<Fr>();
-    let claim = SumcheckClaim::new(driver.num_rounds(), driver.degree(), claimed_sum);
-    let round_proofs = proof
-        .proof
-        .round_polynomials
-        .iter()
-        .map(|poly| CompressedLabeledRoundPoly::new(poly, driver.round_label().as_bytes()))
-        .collect::<Vec<_>>();
-    let output = SumcheckVerifier::verify_optimized(&claim, &round_proofs, transcript)
-        .map_err(|error| map_sumcheck(driver.symbol(), error))?;
-    if !proof.point.is_empty() && proof.point != output.point {
-        return Err(RuntimePlanError::InvalidProof {
-            driver: driver.symbol(),
-            reason: "batched point mismatch",
-        }
-        .into());
-    }
-    let expected = expected_output(store, &proof.evals, &output.point, &batching_coeffs)?;
-    if output.value != expected {
-        return Err(RuntimePlanError::InvalidProof {
-            driver: driver.symbol(),
-            reason: "batched output claim mismatch",
-        }
-        .into());
-    }
-    let verified = StageSumcheckOutput {
-        driver: driver.symbol(),
-        point: output.point,
-        evals: proof.evals.clone(),
-        proof: proof.proof.clone(),
-    };
-    observe_output(store, &verified)?;
-    append_opening_claims(
-        opening_inputs,
-        opening_claims,
-        opening_batches,
-        store,
-        transcript,
-        &verified.evals,
-        |batch, claim| RuntimePlanError::MissingClaim { batch, claim },
-        |symbol| RuntimePlanError::MissingValue { symbol },
-    )?;
-    Ok(verified)
-}
-
-pub fn eval_by_name<F: Field>(
-    evals: &[StageNamedEval<F>],
-    name: &'static str,
-) -> Result<F, RuntimePlanError> {
-    evals
-        .iter()
-        .find(|eval| eval.name == name)
-        .map(|eval| eval.value)
-        .ok_or(RuntimePlanError::MissingValue { symbol: name })
-}
-
-pub fn indexed_evals_by_prefix<F: Field>(
-    evals: &[StageNamedEval<F>],
-    prefix: &'static str,
-    count: usize,
-) -> Result<Vec<F>, RuntimePlanError> {
-    let mut values = vec![None; count];
-    for eval in evals {
-        let Some(suffix) = eval.name.strip_prefix(prefix) else {
-            continue;
-        };
-        let index = suffix
-            .parse::<usize>()
-            .map_err(|_| RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "invalid indexed eval suffix",
-            })?;
-        if index >= count || values[index].is_some() {
-            return Err(RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "invalid indexed eval",
-            });
-        }
-        values[index] = Some(eval.value);
-    }
-    values
-        .into_iter()
-        .map(|value| value.ok_or(RuntimePlanError::MissingValue { symbol: prefix }))
-        .collect()
-}
-
-pub fn indexed_evals_by_prefix_any<F: Field>(
-    evals: &[StageNamedEval<F>],
-    prefix: &'static str,
-) -> Result<Vec<F>, RuntimePlanError> {
-    let mut indexed_values = Vec::new();
-    for eval in evals {
-        let Some(suffix) = eval.name.strip_prefix(prefix) else {
-            continue;
-        };
-        let index = suffix
-            .parse::<usize>()
-            .map_err(|_| RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "invalid indexed eval suffix",
-            })?;
-        if indexed_values
-            .iter()
-            .any(|(existing_index, _)| *existing_index == index)
-        {
-            return Err(RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "duplicate indexed eval",
-            });
-        }
-        indexed_values.push((index, eval.value));
-    }
-    if indexed_values.is_empty() {
-        return Err(RuntimePlanError::MissingValue { symbol: prefix });
-    }
-    indexed_values.sort_by_key(|(index, _)| *index);
-    for (expected, (actual, _)) in indexed_values.iter().enumerate() {
-        if *actual != expected {
-            return Err(RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "non-contiguous indexed eval",
-            });
-        }
-    }
-    Ok(indexed_values.into_iter().map(|(_, value)| value).collect())
-}
-
-pub fn single_operand<F: Field>(
-    symbol: &'static str,
-    operands: &[F],
-) -> Result<F, RuntimePlanError> {
-    require_operand_count(symbol, 1, operands.len())?;
-    Ok(operands[0])
-}
-
-pub fn require_operand_count(
-    input: &'static str,
-    expected: usize,
-    actual: usize,
-) -> Result<(), RuntimePlanError> {
-    if expected == actual {
-        Ok(())
-    } else {
-        Err(RuntimePlanError::InvalidInputLength {
-            input,
-            expected,
-            actual,
-        })
-    }
-}
-
-pub fn evaluate_field_expr<F: Field>(
-    expr: &FieldExprPlan,
-    operands: &[F],
-) -> Result<F, RuntimePlanError> {
-    match expr.formula {
-        "opening_eval" => Ok(single_operand(expr.symbol, operands)?),
-        "field.add" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] + operands[1])
-        }
-        "field.sub" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] - operands[1])
-        }
-        "field.mul" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] * operands[1])
-        }
-        "field.neg" => {
-            require_operand_count(expr.symbol, 1, operands.len())?;
-            Ok(-operands[0])
-        }
-        formula => {
-            if let Some(exponent) = formula.strip_prefix("field.pow:") {
-                require_operand_count(expr.symbol, 1, operands.len())?;
-                let exponent = exponent.parse::<usize>().map_err(|_| {
-                    RuntimePlanError::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                return Ok(pow_field(operands[0], exponent));
-            }
-            Err(RuntimePlanError::UnsupportedFieldExpr {
-                symbol: expr.symbol,
-                formula,
-            })
-        }
-    }
-}
-
-pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] {
-    let mut powers = [Fr::from_u64(1); 8];
-    for index in 1..powers.len() {
-        powers[index] = powers[index - 1] * gamma;
-    }
-    powers
-}
-
-pub fn indexed_boolean_eq(index: usize, point: &[Fr]) -> Fr {
-    point
-        .iter()
-        .enumerate()
-        .map(|(bit, value)| {
-            if (index >> (point.len() - 1 - bit)) & 1 == 1 {
-                *value
-            } else {
-                Fr::from_u64(1) - *value
-            }
-        })
-        .product()
-}
-
-pub fn field_powers(base: Fr, count: usize) -> Vec<Fr> {
-    let mut powers = Vec::with_capacity(count);
-    let mut power = Fr::from_u64(1);
-    for _ in 0..count {
-        powers.push(power);
-        power *= base;
-    }
-    powers
-}
-
-pub fn prefix_point<'a, F: Field>(
-    point: &'a [F],
-    length: usize,
-    input: &'static str,
-) -> Result<&'a [F], RuntimePlanError> {
-    point
-        .get(..length)
-        .filter(|prefix| prefix.len() == length)
-        .ok_or(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: length,
-            actual: point.len(),
-        })
-}
-
-pub fn suffix_point<'a, F: Field>(
-    point: &'a [F],
-    length: usize,
-    input: &'static str,
-) -> Result<&'a [F], RuntimePlanError> {
-    point
-        .get(point.len().saturating_sub(length)..)
-        .filter(|suffix| suffix.len() == length)
-        .ok_or(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: length,
-            actual: point.len(),
-        })
-}
-
-pub fn normalize_bytecode_read_raf_point<F: Field>(
-    point: &[F],
-    log_t: usize,
-    input: &'static str,
-) -> Result<Vec<F>, RuntimePlanError> {
-    let log_k = point
-        .len()
-        .checked_sub(log_t)
-        .ok_or(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: log_t,
-            actual: point.len(),
-        })?;
-    let mut normalized = point.to_vec();
-    normalized[..log_k].reverse();
-    normalized[log_k..].reverse();
-    Ok(normalized)
-}
-
-pub fn normalize_instruction_read_raf_point<F: Field>(
-    point: &[F],
-    input: &'static str,
-) -> Result<Vec<F>, RuntimePlanError> {
-    const LOG_K: usize = 128;
-    if point.len() < LOG_K {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: LOG_K,
-            actual: point.len(),
-        });
-    }
-    let mut normalized = point.to_vec();
-    normalized[LOG_K..].reverse();
-    Ok(normalized)
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Stage67RelationSymbols {
-    pub hamming_booleanity_relation: &'static str,
-    pub hamming_booleanity_instance: &'static str,
-    pub booleanity_point: &'static str,
-    pub stage5_instruction_ra0: &'static str,
-    pub booleanity_combined_point: &'static str,
-    pub booleanity_gamma: &'static str,
-    pub booleanity_instruction_ra_prefix: &'static str,
-    pub booleanity_bytecode_ra_prefix: &'static str,
-    pub booleanity_ram_ra_prefix: &'static str,
-    pub hamming_weight_eval: &'static str,
-    pub hamming_lookup_output: &'static str,
-    pub ram_ra_virtual_cycle: &'static str,
-    pub ram_ra_virtual_eval_prefix: &'static str,
-    pub instruction_ra_virtual_cycle: &'static str,
-    pub instruction_ra_virtual_eval_prefix: &'static str,
-    pub instruction_ra_virtual_input_prefix: &'static str,
-    pub instruction_ra_virtual_gamma: &'static str,
-    pub inc_ram_stage2: &'static str,
-    pub inc_ram_stage4: &'static str,
-    pub inc_rd_stage4: &'static str,
-    pub inc_rd_stage5: &'static str,
-    pub inc_gamma: &'static str,
-    pub inc_ram_eval: &'static str,
-    pub inc_rd_eval: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Stage67BytecodeSymbols {
-    pub point: &'static str,
-    pub gamma: &'static str,
-    pub bytecode_ra_eval_prefix: &'static str,
-    pub entries: &'static str,
-    pub entry_bytecode_index: &'static str,
-    pub stage_gammas: [&'static str; 5],
-    pub stage_cycle_points: [&'static str; 5],
-    pub stage4_register_point: &'static str,
-    pub stage5_register_point: &'static str,
-    pub entry_rd: &'static str,
-    pub entry_rs1: &'static str,
-    pub entry_rs2: &'static str,
-    pub entry_lookup_table: &'static str,
-}
-
-pub trait Stage67BytecodeEntry {
-    fn address(&self) -> Fr;
-    fn imm(&self) -> Fr;
-    fn circuit_flags(&self) -> &[bool; 14];
-    fn rd(&self) -> Option<usize>;
-    fn rs1(&self) -> Option<usize>;
-    fn rs2(&self) -> Option<usize>;
-    fn lookup_table(&self) -> Option<usize>;
-    fn is_interleaved(&self) -> bool;
-    fn is_branch(&self) -> bool;
-    fn left_is_rs1(&self) -> bool;
-    fn left_is_pc(&self) -> bool;
-    fn right_is_rs2(&self) -> bool;
-    fn right_is_imm(&self) -> bool;
-    fn is_noop(&self) -> bool;
-}
-
-pub fn store_scalar(store: &ValueStore<Fr>, symbol: &'static str) -> Result<Fr, RuntimePlanError> {
-    store.scalar_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol })
-}
-
-pub fn store_point<'a>(
-    store: &'a ValueStore<Fr>,
-    symbol: &'static str,
-) -> Result<&'a [Fr], RuntimePlanError> {
-    store.point_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol })
-}
-
-pub fn stage67_trace_rounds(
-    instance_results: &[SumcheckInstanceResultPlan],
-    symbols: &Stage67RelationSymbols,
-) -> Result<usize, RuntimePlanError> {
-    instance_results
-        .iter()
-        .find(|instance| instance.relation == symbols.hamming_booleanity_relation)
-        .map(|instance| instance.num_rounds)
-        .ok_or(RuntimePlanError::MissingValue {
-            symbol: symbols.hamming_booleanity_instance,
-        })
-}
-
-pub fn expected_stage67_bytecode_read_raf<E: Stage67BytecodeEntry>(
-    entries: &[E],
-    entry_bytecode_index: usize,
-    num_lookup_tables: usize,
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    log_t: usize,
-    symbols: &Stage67BytecodeSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, symbols.point)?;
-    let log_k = opening_point.len() - log_t;
-    let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k);
-
-    let gamma = store_scalar(store, symbols.gamma)?;
-    let gamma_powers = bytecode_gamma_powers(gamma);
-    let int_eval = identity_polynomial_eval(r_address_prime);
-    let stage_value_evals = stage67_bytecode_stage_value_evals(
-        entries,
-        entry_bytecode_index,
-        num_lookup_tables,
-        store,
-        r_address_prime,
-        r_cycle_prime.len(),
-        symbols,
-    )?;
-    let stage_cycle_points =
-        stage67_bytecode_stage_cycle_points(store, r_cycle_prime.len(), symbols)?;
-    let int_contrib = [
-        gamma_powers[5] * int_eval,
-        Fr::from_u64(0),
-        gamma_powers[4] * int_eval,
-        Fr::from_u64(0),
-        Fr::from_u64(0),
-    ];
-
-    let mut val = Fr::from_u64(0);
-    for index in 0..stage_value_evals.len() {
-        val += (stage_value_evals[index] + int_contrib[index])
-            * EqPolynomial::<Fr>::mle(&stage_cycle_points[index], r_cycle_prime)
-            * gamma_powers[index];
-    }
-
-    let entry_bits = (0..log_k)
-        .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64))
-        .collect::<Vec<_>>();
-    let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()];
-    let entry_contrib = gamma_powers[7]
-        * EqPolynomial::<Fr>::mle(&entry_bits, r_address_prime)
-        * EqPolynomial::<Fr>::mle(&zero_cycle, r_cycle_prime);
-    let bytecode_ra = indexed_evals_by_prefix_any(evals, symbols.bytecode_ra_eval_prefix)?
-        .into_iter()
-        .product::<Fr>();
-    Ok((val + entry_contrib) * bytecode_ra)
-}
-
-pub fn expected_stage67_booleanity(
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    log_t: usize,
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let log_k_chunk =
-        local_point
-            .len()
-            .checked_sub(log_t)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input: symbols.booleanity_point,
-                expected: log_t,
-                actual: local_point.len(),
-            })?;
-    let stage5_point = store_point(store, symbols.stage5_instruction_ra0)?;
-    let stage5_address_len =
-        stage5_point
-            .len()
-            .checked_sub(log_t)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input: symbols.stage5_instruction_ra0,
-                expected: log_t,
-                actual: stage5_point.len(),
-            })?;
-    if stage5_address_len < log_k_chunk {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.stage5_instruction_ra0,
-            expected: log_k_chunk + log_t,
-            actual: stage5_point.len(),
-        });
-    }
-
-    let mut stage5_addr = stage5_point[..stage5_address_len].to_vec();
-    stage5_addr.reverse();
-    let mut combined_r = stage5_addr[stage5_address_len - log_k_chunk..].to_vec();
-    combined_r.extend(stage5_point[stage5_address_len..].iter().rev().copied());
-    if combined_r.len() != local_point.len() {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.booleanity_combined_point,
-            expected: local_point.len(),
-            actual: combined_r.len(),
-        });
-    }
-    let mut verifier_point = combined_r[..log_k_chunk].to_vec();
-    verifier_point.reverse();
-    verifier_point.extend(combined_r[log_k_chunk..].iter().rev().copied());
-    let eq_eval = EqPolynomial::<Fr>::mle(local_point, &verifier_point);
-
-    let gamma = store_scalar(store, symbols.booleanity_gamma)?;
-    let gamma_sq = gamma.square();
-    let mut gamma_power = Fr::from_u64(1);
-    let mut booleanity = Fr::from_u64(0);
-    for ra in stage67_booleanity_evals(evals, symbols)? {
-        booleanity += gamma_power * (ra.square() - ra);
-        gamma_power *= gamma_sq;
-    }
-    Ok(eq_eval * booleanity)
-}
-
-pub fn expected_stage67_hamming_booleanity(
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let hamming = eval_by_name(evals, symbols.hamming_weight_eval)?;
-    let lookup_output_point = reverse_slice(store_point(store, symbols.hamming_lookup_output)?);
-    if lookup_output_point.len() != local_point.len() {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.hamming_lookup_output,
-            expected: local_point.len(),
-            actual: lookup_output_point.len(),
-        });
-    }
-    let eq_eval = EqPolynomial::<Fr>::mle(local_point, &lookup_output_point);
-    Ok((hamming.square() - hamming) * eq_eval)
-}
-
-pub fn expected_stage67_ram_ra_virtual(
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let r_cycle_reduced = reverse_slice(local_point);
-    let r_cycle = suffix_point(
-        store_point(store, symbols.ram_ra_virtual_cycle)?,
-        r_cycle_reduced.len(),
-        symbols.ram_ra_virtual_cycle,
-    )?;
-    let eq_eval = EqPolynomial::<Fr>::mle(r_cycle, &r_cycle_reduced);
-    let ram_ra = indexed_evals_by_prefix_any(evals, symbols.ram_ra_virtual_eval_prefix)?
-        .into_iter()
-        .product::<Fr>();
-    Ok(eq_eval * ram_ra)
-}
-
-pub fn expected_stage67_instruction_ra_virtual(
-    opening_inputs: &[OpeningInputPlan],
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let r_cycle_reduced = reverse_slice(local_point);
-    let r_cycle = suffix_point(
-        store_point(store, symbols.instruction_ra_virtual_cycle)?,
-        r_cycle_reduced.len(),
-        symbols.instruction_ra_virtual_cycle,
-    )?;
-    let eq_eval = EqPolynomial::<Fr>::mle(r_cycle, &r_cycle_reduced);
-    let committed_ra =
-        indexed_evals_by_prefix_any(evals, symbols.instruction_ra_virtual_eval_prefix)?;
-    let virtual_count = opening_inputs
-        .iter()
-        .filter(|input| {
-            input
-                .symbol
-                .starts_with(symbols.instruction_ra_virtual_input_prefix)
-        })
-        .count();
-    if virtual_count == 0 || committed_ra.len() % virtual_count != 0 {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.instruction_ra_virtual_eval_prefix,
-            expected: virtual_count,
-            actual: committed_ra.len(),
-        });
-    }
-    let committed_per_virtual = committed_ra.len() / virtual_count;
-    let gamma = store_scalar(store, symbols.instruction_ra_virtual_gamma)?;
-    let mut gamma_power = Fr::from_u64(1);
-    let mut value = Fr::from_u64(0);
-    for chunk in committed_ra.chunks(committed_per_virtual) {
-        value += gamma_power * chunk.iter().copied().product::<Fr>();
-        gamma_power *= gamma;
-    }
-    Ok(eq_eval * value)
-}
-
-pub fn expected_stage67_inc_claim_reduction(
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let r_cycle_reduced = reverse_slice(local_point);
-    let ram_inc_stage2 = suffix_point(
-        store_point(store, symbols.inc_ram_stage2)?,
-        r_cycle_reduced.len(),
-        symbols.inc_ram_stage2,
-    )?;
-    let ram_inc_stage4 = suffix_point(
-        store_point(store, symbols.inc_ram_stage4)?,
-        r_cycle_reduced.len(),
-        symbols.inc_ram_stage4,
-    )?;
-    let rd_inc_stage4 = suffix_point(
-        store_point(store, symbols.inc_rd_stage4)?,
-        r_cycle_reduced.len(),
-        symbols.inc_rd_stage4,
-    )?;
-    let rd_inc_stage5 = suffix_point(
-        store_point(store, symbols.inc_rd_stage5)?,
-        r_cycle_reduced.len(),
-        symbols.inc_rd_stage5,
-    )?;
-    let gamma = store_scalar(store, symbols.inc_gamma)?;
-    let eq_ram_combined = EqPolynomial::<Fr>::mle(ram_inc_stage2, &r_cycle_reduced)
-        + gamma * EqPolynomial::<Fr>::mle(ram_inc_stage4, &r_cycle_reduced);
-    let eq_rd_combined = EqPolynomial::<Fr>::mle(rd_inc_stage4, &r_cycle_reduced)
-        + gamma * EqPolynomial::<Fr>::mle(rd_inc_stage5, &r_cycle_reduced);
-    let ram_inc = eval_by_name(evals, symbols.inc_ram_eval)?;
-    let rd_inc = eval_by_name(evals, symbols.inc_rd_eval)?;
-    Ok(ram_inc * eq_ram_combined + gamma.square() * rd_inc * eq_rd_combined)
-}
-
-fn stage67_booleanity_evals(
-    evals: &[StageNamedEval<Fr>],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Vec<Fr>, RuntimePlanError> {
-    let mut values = indexed_evals_by_prefix_any(evals, symbols.booleanity_instruction_ra_prefix)?;
-    values.extend(indexed_evals_by_prefix_any(
-        evals,
-        symbols.booleanity_bytecode_ra_prefix,
-    )?);
-    values.extend(indexed_evals_by_prefix_any(
-        evals,
-        symbols.booleanity_ram_ra_prefix,
-    )?);
-    Ok(values)
-}
-
-fn stage67_bytecode_stage_cycle_points(
-    store: &ValueStore<Fr>,
-    log_t: usize,
-    symbols: &Stage67BytecodeSymbols,
-) -> Result<[Vec<Fr>; 5], RuntimePlanError> {
-    let point = |index| {
-        let symbol = symbols.stage_cycle_points[index];
-        suffix_point(store_point(store, symbol)?, log_t, symbol).map(|point| point.to_vec())
-    };
-    Ok([point(0)?, point(1)?, point(2)?, point(3)?, point(4)?])
-}
-
-fn stage67_bytecode_stage_value_evals<E: Stage67BytecodeEntry>(
-    entries: &[E],
-    entry_bytecode_index: usize,
-    num_lookup_tables: usize,
-    store: &ValueStore<Fr>,
-    r_address: &[Fr],
-    log_t: usize,
-    symbols: &Stage67BytecodeSymbols,
-) -> Result<[Fr; 5], RuntimePlanError> {
-    let expected_len =
-        1usize
-            .checked_shl(r_address.len() as u32)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input: symbols.entries,
-                expected: usize::BITS as usize,
-                actual: r_address.len(),
-            })?;
-    if entries.len() != expected_len {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.entries,
-            expected: expected_len,
-            actual: entries.len(),
-        });
-    }
-    if entry_bytecode_index >= expected_len {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.entry_bytecode_index,
-            expected: expected_len,
-            actual: entry_bytecode_index + 1,
-        });
-    }
-
-    let stage1_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[0])?, 16);
-    let stage2_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[1])?, 4);
-    let stage3_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[2])?, 9);
-    let stage4_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[3])?, 3);
-    let stage5_gamma_powers = field_powers(
-        store_scalar(store, symbols.stage_gammas[4])?,
-        num_lookup_tables + 2,
-    );
-
-    let stage4_register_point =
-        stage67_register_prefix_point(store, symbols.stage4_register_point, log_t)?;
-    let stage5_register_point =
-        stage67_register_prefix_point(store, symbols.stage5_register_point, log_t)?;
-
-    let mut evals = [Fr::from_u64(0); 5];
-    for (index, entry) in entries.iter().enumerate() {
-        let eq = indexed_boolean_eq(index, r_address);
-        let values = stage67_bytecode_entry_stage_values(
-            entry,
-            num_lookup_tables,
-            stage4_register_point,
-            stage5_register_point,
-            &stage1_gamma_powers,
-            &stage2_gamma_powers,
-            &stage3_gamma_powers,
-            &stage4_gamma_powers,
-            &stage5_gamma_powers,
-            symbols,
-        )?;
-        for stage in 0..evals.len() {
-            evals[stage] += eq * values[stage];
-        }
-    }
-    Ok(evals)
-}
-
-fn stage67_bytecode_entry_stage_values<E: Stage67BytecodeEntry>(
-    entry: &E,
-    num_lookup_tables: usize,
-    stage4_register_point: &[Fr],
-    stage5_register_point: &[Fr],
-    stage1_gamma_powers: &[Fr],
-    stage2_gamma_powers: &[Fr],
-    stage3_gamma_powers: &[Fr],
-    stage4_gamma_powers: &[Fr],
-    stage5_gamma_powers: &[Fr],
-    symbols: &Stage67BytecodeSymbols,
-) -> Result<[Fr; 5], RuntimePlanError> {
-    let flags = entry.circuit_flags();
-    let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1];
-    for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) {
-        if *flag {
-            stage1 += *gamma;
-        }
-    }
-
-    let mut stage2 = Fr::from_u64(0);
-    if flags[5] {
-        stage2 += stage2_gamma_powers[0];
-    }
-    if entry.is_branch() {
-        stage2 += stage2_gamma_powers[1];
-    }
-    if flags[6] {
-        stage2 += stage2_gamma_powers[2];
-    }
-    if flags[7] {
-        stage2 += stage2_gamma_powers[3];
-    }
-
-    let mut stage3 = entry.imm() + entry.address() * stage3_gamma_powers[1];
-    if entry.left_is_rs1() {
-        stage3 += stage3_gamma_powers[2];
-    }
-    if entry.left_is_pc() {
-        stage3 += stage3_gamma_powers[3];
-    }
-    if entry.right_is_rs2() {
-        stage3 += stage3_gamma_powers[4];
-    }
-    if entry.right_is_imm() {
-        stage3 += stage3_gamma_powers[5];
-    }
-    if entry.is_noop() {
-        stage3 += stage3_gamma_powers[6];
-    }
-    if flags[7] {
-        stage3 += stage3_gamma_powers[7];
-    }
-    if flags[12] {
-        stage3 += stage3_gamma_powers[8];
-    }
-
-    let stage4 = stage67_register_eq(entry.rd(), stage4_register_point, symbols.entry_rd)?
-        * stage4_gamma_powers[0]
-        + stage67_register_eq(entry.rs1(), stage4_register_point, symbols.entry_rs1)?
-            * stage4_gamma_powers[1]
-        + stage67_register_eq(entry.rs2(), stage4_register_point, symbols.entry_rs2)?
-            * stage4_gamma_powers[2];
-
-    let mut stage5 = stage67_register_eq(entry.rd(), stage5_register_point, symbols.entry_rd)?
-        * stage5_gamma_powers[0];
-    if !entry.is_interleaved() {
-        stage5 += stage5_gamma_powers[1];
-    }
-    if let Some(table) = entry.lookup_table() {
-        if table >= num_lookup_tables {
-            return Err(RuntimePlanError::InvalidInputLength {
-                input: symbols.entry_lookup_table,
-                expected: num_lookup_tables,
-                actual: table + 1,
-            });
-        }
-        stage5 += stage5_gamma_powers[2 + table];
-    }
-
-    Ok([stage1, stage2, stage3, stage4, stage5])
-}
-
-fn stage67_register_eq(
-    index: Option<usize>,
-    point: &[Fr],
-    input: &'static str,
-) -> Result<Fr, RuntimePlanError> {
-    let Some(index) = index else {
-        return Ok(Fr::from_u64(0));
-    };
-    let register_count =
-        1usize
-            .checked_shl(point.len() as u32)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input,
-                expected: usize::BITS as usize,
-                actual: point.len(),
-            })?;
-    if index >= register_count {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: register_count,
-            actual: index + 1,
-        });
-    }
-    Ok(indexed_boolean_eq(index, point))
-}
-
-fn stage67_register_prefix_point<'a>(
-    store: &'a ValueStore<Fr>,
-    symbol: &'static str,
-    log_t: usize,
-) -> Result<&'a [Fr], RuntimePlanError> {
-    let point = store_point(store, symbol)?;
-    let register_len =
-        point
-            .len()
-            .checked_sub(log_t)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input: symbol,
-                expected: log_t,
-                actual: point.len(),
-            })?;
-    prefix_point(point, register_len, symbol)
-}
-
-pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Fr {
-    let stride_offset = usize::from(!left);
-    let operand_bits = point.len() / 2;
-    (0..operand_bits)
-        .map(|index| point[2 * index + stride_offset].mul_pow_2(operand_bits - 1 - index))
-        .sum()
-}
-
-pub fn identity_polynomial_eval(point: &[Fr]) -> Fr {
-    point
-        .iter()
-        .enumerate()
-        .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index))
-        .sum()
-}
-
-pub fn append_labeled_scalar<T>(transcript: &mut T, label: &'static str, scalar: &Fr)
-where
-    T: Transcript<Challenge = Fr>,
-{
-    transcript.append(&Label(label.as_bytes()));
-    transcript.append(scalar);
-}
-
-pub fn append_opening_claims<T, E>(
-    opening_inputs: &[OpeningInputPlan],
-    opening_claims: &[OpeningClaimPlan],
-    opening_batches: &[OpeningBatchPlan],
-    store: &mut ValueStore<Fr>,
-    transcript: &mut T,
-    evals: &[StageNamedEval<Fr>],
-    missing_claim: impl Fn(&'static str, &'static str) -> E,
-    missing_value: impl Fn(&'static str) -> E,
-) -> Result<(), E>
-where
-    T: Transcript<Challenge = Fr>,
-{
-    if opening_batches.is_empty() {
-        for eval in evals {
-            append_labeled_scalar(transcript, "opening_claim", &eval.value);
-        }
-        return Ok(());
-    }
-    let mut seen = opening_inputs
-        .iter()
-        .filter_map(|input| {
-            store
-                .try_point(input.symbol)
-                .map(|point| (input.claim_kind, input.oracle, point.to_vec()))
-        })
-        .collect::<Vec<_>>();
-    for batch in opening_batches {
-        for symbol in symbol_list(batch.claim_operands) {
-            let claim = opening_claims
-                .iter()
-                .find(|claim| claim.symbol == symbol)
-                .ok_or_else(|| missing_claim(batch.symbol, symbol))?;
-            let point = store.point_or(claim.point_source, &missing_value)?.to_vec();
-            if seen.iter().any(|(kind, oracle, seen_point)| {
-                *kind == claim.claim_kind && *oracle == claim.oracle && seen_point == &point
-            }) {
-                continue;
-            }
-            let value = store.scalar_or(claim.eval_source, &missing_value)?;
-            append_labeled_scalar(transcript, "opening_claim", &value);
-            seen.push((claim.claim_kind, claim.oracle, point));
-        }
-    }
-    Ok(())
-}
-
-pub fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Fr {
-    let mut lt_eval = Fr::from_u64(0);
-    let mut eq_term = Fr::from_u64(1);
-    for (x_i, y_i) in x.iter().zip(y.iter()) {
-        lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term;
-        eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i;
-    }
-    lt_eval
-}
-
-pub fn pow_field<F: Field>(base: F, mut exponent: usize) -> F {
-    let mut result = F::one();
-    let mut power = base;
-    while exponent != 0 {
-        if exponent & 1 == 1 {
-            result *= power;
-        }
-        power = power.square();
-        exponent >>= 1;
-    }
-    result
-}
-
-pub fn reverse_slice(values: &[Fr]) -> Vec<Fr> {
-    values.iter().rev().copied().collect()
-}
diff --git a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs
new file mode 100644
index 0000000000..015f9d78b4
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs
@@ -0,0 +1,217 @@
+use melior::ir::OperationRef;
+
+use crate::emit::rust::{push_format, EmitError};
+use crate::protocols::jolt::cpu_attrs::{int_attr, string_attr, symbol_array_attr};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct IndexedEvalFamilyPlan {
+    pub(crate) symbol: String,
+    pub(crate) evals: Vec<String>,
+}
+
+impl IndexedEvalFamilyPlan {
+    pub(crate) fn from_parts(
+        symbol: String,
+        evals: Vec<String>,
+        count: usize,
+    ) -> Result<Self, EmitError> {
+        if count != evals.len() {
+            return Err(EmitError::new(format!(
+                "indexed eval family @{symbol} count mismatch: expected {count}, got {}",
+                evals.len()
+            )));
+        }
+        Ok(Self { symbol, evals })
+    }
+
+    pub(crate) fn find_with_index<'a>(
+        families: &'a [Self],
+        symbol: &str,
+    ) -> Result<(usize, &'a IndexedEvalFamilyPlan), EmitError> {
+        let mut matching_families = families
+            .iter()
+            .enumerate()
+            .filter(|(_, family)| family.symbol == symbol);
+        let (index, family) = matching_families
+            .next()
+            .ok_or_else(|| EmitError::new(format!("missing eval family `{symbol}`")))?;
+        if matching_families.next().is_some() {
+            return Err(EmitError::new(format!("duplicate eval family `{symbol}`")));
+        }
+        Ok((index, family))
+    }
+}
+
+pub(crate) fn emit_runtime_slice_constant(
+    families: &[IndexedEvalFamilyPlan],
+    visibility: &str,
+    names_prefix: &str,
+    families_const: &str,
+    family_type: &str,
+) -> String {
+    let mut source = String::new();
+    let mut family_rows = Vec::with_capacity(families.len());
+    for (index, family) in families.iter().enumerate() {
+        let names_const = format!("{names_prefix}_{index}_NAMES");
+        let names_source = family
+            .evals
+            .iter()
+            .map(|name| rust_str(name))
+            .collect::<Vec<_>>()
+            .join(", ");
+        push_format(
+            &mut source,
+            format_args!("#[rustfmt::skip]\nconst {names_const}: &[&str] = &[{names_source}];\n"),
+        );
+        family_rows.push(format!(
+            "    {family_type} {{ symbol: {}, evals: {names_const} }},",
+            rust_str(&family.symbol),
+        ));
+    }
+    push_format(
+        &mut source,
+        format_args!(
+            "{visibility}const {families_const}: &[{family_type}] = &[\n{}\n];\n\n",
+            family_rows.join("\n"),
+        ),
+    );
+    source
+}
+
+pub(crate) fn emit_named_runtime_slice_constant(
+    families: &[IndexedEvalFamilyPlan],
+    visibility: &str,
+    names_prefix: &str,
+    families_const: &str,
+) -> String {
+    emit_runtime_slice_constant(
+        families,
+        visibility,
+        names_prefix,
+        families_const,
+        "bolt_verifier_runtime::NamedEvalFamilyPlan",
+    )
+}
+
+pub(crate) fn parse_indexed_eval_family(
+    operation: OperationRef<'_, '_>,
+) -> Result<IndexedEvalFamilyPlan, EmitError> {
+    let symbol = string_attr(operation, "sym_name")?;
+    let evals = symbol_array_attr(operation, "evals")?;
+    IndexedEvalFamilyPlan::from_parts(symbol, evals, int_attr(operation, "count")?)
+}
+
+fn rust_str(value: &str) -> String {
+    format!("{value:?}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        emit_named_runtime_slice_constant, emit_runtime_slice_constant, IndexedEvalFamilyPlan,
+    };
+
+    #[test]
+    fn find_with_index_rejects_missing_families() {
+        let error = IndexedEvalFamilyPlan::find_with_index(&[], "stage.eval.LookupTableFlag")
+            .err()
+            .map(|error| error.to_string())
+            .unwrap_or_default();
+
+        assert!(error.contains("missing eval family `stage.eval.LookupTableFlag`"));
+    }
+
+    #[test]
+    fn from_parts_rejects_count_mismatch() {
+        let error = IndexedEvalFamilyPlan::from_parts(
+            "stage.eval.BytecodeRa".to_owned(),
+            vec!["stage.eval.BytecodeRa_0".to_owned()],
+            2,
+        )
+        .err()
+        .map(|error| error.to_string())
+        .unwrap_or_default();
+
+        assert!(error.contains(
+            "indexed eval family @stage.eval.BytecodeRa count mismatch: expected 2, got 1"
+        ));
+    }
+
+    #[test]
+    fn find_with_index_rejects_duplicate_families() {
+        let families = [
+            IndexedEvalFamilyPlan {
+                symbol: "stage.eval.BytecodeRa".to_owned(),
+                evals: vec!["stage.eval.BytecodeRa_0".to_owned()],
+            },
+            IndexedEvalFamilyPlan {
+                symbol: "stage.eval.BytecodeRa".to_owned(),
+                evals: vec!["stage.eval.BytecodeRa_1".to_owned()],
+            },
+        ];
+
+        let error = IndexedEvalFamilyPlan::find_with_index(&families, "stage.eval.BytecodeRa")
+            .err()
+            .map(|error| error.to_string())
+            .unwrap_or_default();
+
+        assert!(error.contains("duplicate eval family `stage.eval.BytecodeRa`"));
+    }
+
+    #[test]
+    fn find_with_index_preserves_family_row_position() -> Result<(), crate::emit::rust::EmitError> {
+        let families = [
+            IndexedEvalFamilyPlan {
+                symbol: "stage.eval.LookupTableFlag".to_owned(),
+                evals: vec!["stage.eval.LookupTableFlag_0".to_owned()],
+            },
+            IndexedEvalFamilyPlan {
+                symbol: "stage.eval.BytecodeRa".to_owned(),
+                evals: vec!["stage.eval.BytecodeRa_0".to_owned()],
+            },
+        ];
+
+        let (index, family) =
+            IndexedEvalFamilyPlan::find_with_index(&families, "stage.eval.BytecodeRa")?;
+
+        assert_eq!(index, 1);
+        assert_eq!(family.symbol, "stage.eval.BytecodeRa");
+        Ok(())
+    }
+
+    #[test]
+    fn emit_runtime_slice_constant_groups_eval_families() {
+        let source = emit_runtime_slice_constant(
+            &[IndexedEvalFamilyPlan {
+                symbol: "stage.eval.BytecodeRa".to_owned(),
+                evals: vec![
+                    "stage.eval.BytecodeRa_0".to_owned(),
+                    "stage.eval.BytecodeRa_1".to_owned(),
+                ],
+            }],
+            "pub ",
+            "STAGE_EVAL_FAMILY",
+            "STAGE_EVAL_FAMILIES",
+            "bolt_verifier_runtime::NamedEvalFamilyPlan",
+        );
+
+        assert!(source.contains("pub const STAGE_EVAL_FAMILIES"));
+        assert!(source.contains("STAGE_EVAL_FAMILY_0_NAMES"));
+        assert!(source.contains("stage.eval.BytecodeRa_1"));
+    }
+
+    #[test]
+    fn emit_named_runtime_slice_constant_uses_runtime_family_plan() {
+        let source = emit_named_runtime_slice_constant(
+            &[IndexedEvalFamilyPlan {
+                symbol: "stage.eval.BytecodeRa".to_owned(),
+                evals: vec!["stage.eval.BytecodeRa_0".to_owned()],
+            }],
+            "pub ",
+            "STAGE_EVAL_FAMILY",
+            "STAGE_EVAL_FAMILIES",
+        );
+
+        assert!(source.contains("bolt_verifier_runtime::NamedEvalFamilyPlan"));
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template
new file mode 100644
index 0000000000..4615299bfe
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template
@@ -0,0 +1,696 @@
+#![expect(
+    clippy::too_many_arguments,
+    reason = "Stage 6/7 verifier relation helpers thread typed plan symbols and store/eval slices through their argument lists"
+)]
+
+//! Tier B: Audited Jolt verifier core.
+//!
+//! This module is **not** generic Bolt scaffolding. It is the hand-written
+//! Jolt-specific verifier math that the Bolt compiler does not yet lower
+//! from MLIR. It includes:
+//!
+//! - point normalizations for the Jolt bytecode and instruction RA
+//!   read-RAF lookup arguments
+//! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement
+//! - typed bytecode read-RAF plan data and its small Jolt-specific evaluator
+//! - the small Jolt-specific field-math helpers
+//!   (`operand_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt
+//!   verification
+//!
+//! Treat changes here as Jolt protocol changes, not as compiler-output
+//! cleanups. Generic Bolt verifier scaffolding (typed plan structs,
+//! `ValueStore`, generic sumcheck verification, generic field-expr
+//! dispatch) lives in `bolt_verifier_runtime` instead.
+//!
+//! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition.
+
+use jolt_field::{Field, Fr};
+use jolt_lookup_tables::LookupTableKind;
+use jolt_poly::{EqPolynomial, IdentityPolynomial};
+
+use bolt_verifier_runtime::{
+    field_powers, prefix_point, store_point, store_scalar, suffix_point, NamedEvalFamilyPlan,
+    NamedScalar, RuntimePlanError, SumcheckInstanceResultPlan, ValueStore,
+};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[rustfmt::skip]
+pub enum JoltRelationKind { Stage1OuterUniskip, Stage1OuterRemaining, Stage2ProductVirtualUniskip, Stage2RamReadWrite, Stage2ProductVirtualRemainder, Stage2InstructionLookupClaimReduction, Stage2RamRafEvaluation, Stage2RamOutputCheck, Stage2Batched, Stage3SpartanShift, Stage3InstructionInput, Stage3RegistersClaimReduction, Stage3Batched, Stage4RegistersReadWrite, Stage4RamValCheck, Stage4Batched, Stage5InstructionReadRaf, Stage5RamRaClaimReduction, Stage5RegistersValEvaluation, Stage5Batched, Stage6BytecodeReadRaf, Stage6Booleanity, Stage6HammingBooleanity, Stage6RamRaVirtual, Stage6InstructionRaVirtual, Stage6IncClaimReduction, Stage6Batched, Stage7HammingWeightClaimReduction, Stage7Batched }
+
+pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] {
+    let mut powers = [Fr::from_u64(1); 8];
+    for index in 1..powers.len() {
+        powers[index] = powers[index - 1] * gamma;
+    }
+    powers
+}
+
+pub fn normalize_bytecode_read_raf_point<F: Field>(
+    point: &[F],
+    log_t: usize,
+    input: &'static str,
+) -> Result<Vec<F>, RuntimePlanError> {
+    let log_k = point
+        .len()
+        .checked_sub(log_t)
+        .ok_or(RuntimePlanError::InvalidInputLength {
+            input,
+            expected: log_t,
+            actual: point.len(),
+        })?;
+    let mut normalized = point.to_vec();
+    normalized[..log_k].reverse();
+    normalized[log_k..].reverse();
+    Ok(normalized)
+}
+
+pub fn normalize_instruction_read_raf_point<F: Field>(
+    point: &[F],
+    input: &'static str,
+) -> Result<Vec<F>, RuntimePlanError> {
+    const LOG_K: usize = 128;
+    if point.len() < LOG_K {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input,
+            expected: LOG_K,
+            actual: point.len(),
+        });
+    }
+    let mut normalized = point.to_vec();
+    normalized[LOG_K..].reverse();
+    Ok(normalized)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage67RelationSymbols {
+    pub hamming_booleanity_instance: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage5InstructionReadRafPlan {
+    pub point: &'static str,
+    pub lookup_output_point: &'static str,
+    pub table_flag_evals: &'static NamedEvalFamilyPlan,
+    pub instruction_ra_evals: &'static NamedEvalFamilyPlan,
+    pub raf_flag_eval: &'static str,
+    pub gamma: &'static str,
+    pub local_scalars: &'static [JoltLocalScalarPlan],
+    pub log_k: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct JoltLocalScalarPlan {
+    pub symbol: &'static str,
+    pub kind: JoltLocalScalarMleKind,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum JoltLocalScalarMleKind {
+    LookupTable { index: usize },
+    LeftOperand,
+    RightOperand,
+    Identity,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage67BytecodeReadRafPlan {
+    pub point: &'static str,
+    pub gamma: &'static str,
+    pub bytecode_ra_evals: &'static NamedEvalFamilyPlan,
+    pub entries: &'static str,
+    pub entry_bytecode_index: &'static str,
+    pub stages: &'static [Stage67BytecodeStagePlan],
+    pub output_terms: &'static [Stage67BytecodeOutputTermPlan],
+    pub output_contribution: &'static str,
+    pub registers: Stage67BytecodeRegisterSymbols,
+    pub entry_lookup_table: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage67BytecodeStagePlan {
+    pub gamma: &'static str,
+    pub cycle_point: &'static str,
+    pub register_point: Option<&'static str>,
+    pub terms: &'static [Stage67BytecodeTermPlan],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage67BytecodeOutputTermPlan {
+    StageValue {
+        symbol: &'static str,
+        stage_index: usize,
+        gamma_power: usize,
+        identity_gamma_power: Option<usize>,
+    },
+    Entry {
+        symbol: &'static str,
+        gamma_power: usize,
+    },
+}
+
+impl Stage67BytecodeOutputTermPlan {
+    fn symbol(self) -> &'static str {
+        match self {
+            Self::StageValue { symbol, .. } | Self::Entry { symbol, .. } => symbol,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage67BytecodeRegisterSymbols {
+    pub rd: &'static str,
+    pub rs1: &'static str,
+    pub rs2: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage67BytecodeTermPlan {
+    Address {
+        gamma_power: usize,
+    },
+    Imm {
+        gamma_power: usize,
+    },
+    CircuitFlag {
+        index: usize,
+        gamma_power: usize,
+    },
+    EntryFlag {
+        flag: Stage67BytecodeFlag,
+        expected: bool,
+        gamma_power: usize,
+    },
+    RegisterEq {
+        register: Stage67BytecodeRegister,
+        gamma_power: usize,
+    },
+    LookupTable {
+        gamma_base: usize,
+    },
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage67BytecodeFlag {
+    IsInterleaved,
+    IsBranch,
+    LeftIsRs1,
+    LeftIsPc,
+    RightIsRs2,
+    RightIsImm,
+    IsNoop,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage67BytecodeRegister {
+    Rd,
+    Rs1,
+    Rs2,
+}
+
+pub trait Stage67BytecodeEntry {
+    fn address(&self) -> Fr;
+    fn imm(&self) -> Fr;
+    fn circuit_flags(&self) -> &[bool; 14];
+    fn rd(&self) -> Option<usize>;
+    fn rs1(&self) -> Option<usize>;
+    fn rs2(&self) -> Option<usize>;
+    fn lookup_table(&self) -> Option<usize>;
+    fn is_interleaved(&self) -> bool;
+    fn is_branch(&self) -> bool;
+    fn left_is_rs1(&self) -> bool;
+    fn left_is_pc(&self) -> bool;
+    fn right_is_rs2(&self) -> bool;
+    fn right_is_imm(&self) -> bool;
+    fn is_noop(&self) -> bool;
+}
+
+pub fn evaluate_stage5_instruction_read_raf_local_scalars(
+    plan: &Stage5InstructionReadRafPlan,
+    local_point: &[Fr],
+) -> Result<Vec<NamedScalar<Fr>>, RuntimePlanError> {
+    let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?;
+    evaluate_jolt_local_scalars(plan.local_scalars, r_address_prime)
+}
+
+pub fn evaluate_jolt_local_scalars(
+    plans: &[JoltLocalScalarPlan],
+    point: &[Fr],
+) -> Result<Vec<NamedScalar<Fr>>, RuntimePlanError> {
+    let mut scalars = Vec::with_capacity(plans.len());
+    for value in plans {
+        let scalar = evaluate_jolt_local_scalar(value.kind, point)?;
+        scalars.push(NamedScalar {
+            symbol: value.symbol,
+            value: scalar,
+        });
+    }
+    Ok(scalars)
+}
+
+fn evaluate_jolt_local_scalar(
+    kind: JoltLocalScalarMleKind,
+    point: &[Fr],
+) -> Result<Fr, RuntimePlanError> {
+    const XLEN: usize = 64;
+    Ok(match kind {
+        JoltLocalScalarMleKind::LookupTable { index } => {
+            let tables = LookupTableKind::<XLEN>::all();
+            let table = tables
+                .get(index)
+                .ok_or(RuntimePlanError::InvalidInputLength {
+                    input: "stage5.instruction_read_raf.lookup_table",
+                    expected: tables.len(),
+                    actual: index + 1,
+                })?;
+            table.evaluate_mle::<Fr, Fr>(point)
+        }
+        JoltLocalScalarMleKind::LeftOperand => operand_polynomial_eval(point, true)?,
+        JoltLocalScalarMleKind::RightOperand => operand_polynomial_eval(point, false)?,
+        JoltLocalScalarMleKind::Identity => IdentityPolynomial::new(point.len()).evaluate(point),
+    })
+}
+
+fn instruction_read_raf_point_parts<'a>(
+    plan: &Stage5InstructionReadRafPlan,
+    local_point: &'a [Fr],
+) -> Result<(&'a [Fr], &'a [Fr]), RuntimePlanError> {
+    if local_point.len() < plan.log_k {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input: plan.point,
+            expected: plan.log_k,
+            actual: local_point.len(),
+        });
+    }
+    Ok(local_point.split_at(plan.log_k))
+}
+
+pub fn stage67_trace_rounds(
+    instance_results: &[SumcheckInstanceResultPlan<JoltRelationKind>],
+    symbols: &Stage67RelationSymbols,
+) -> Result<usize, RuntimePlanError> {
+    instance_results
+        .iter()
+        .find(|instance| instance.relation == JoltRelationKind::Stage6HammingBooleanity)
+        .map(|instance| instance.num_rounds)
+        .ok_or(RuntimePlanError::MissingValue {
+            symbol: symbols.hamming_booleanity_instance,
+        })
+}
+
+pub fn evaluate_stage67_bytecode_read_raf_output_scalars<E: Stage67BytecodeEntry>(
+    plan: &Stage67BytecodeReadRafPlan,
+    entries: &[E],
+    entry_bytecode_index: usize,
+    num_lookup_tables: usize,
+    store: &ValueStore<Fr>,
+    local_point: &[Fr],
+    log_t: usize,
+) -> Result<Vec<NamedScalar<Fr>>, RuntimePlanError> {
+    let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, plan.point)?;
+    let log_k = opening_point.len() - log_t;
+    let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k);
+
+    let gamma = store_scalar(store, plan.gamma)?;
+    let gamma_powers = bytecode_gamma_powers(gamma);
+    let stage_value_evals = stage67_bytecode_stage_value_evals(
+        plan,
+        entries,
+        entry_bytecode_index,
+        num_lookup_tables,
+        store,
+        r_address_prime,
+        r_cycle_prime.len(),
+    )?;
+    stage67_bytecode_output_terms(
+        plan,
+        store,
+        &stage_value_evals,
+        &gamma_powers,
+        entry_bytecode_index,
+        r_address_prime,
+        r_cycle_prime,
+        log_k,
+    )
+}
+
+fn stage67_bytecode_output_terms(
+    plan: &Stage67BytecodeReadRafPlan,
+    store: &ValueStore<Fr>,
+    stage_value_evals: &[Fr],
+    gamma_powers: &[Fr],
+    entry_bytecode_index: usize,
+    r_address_prime: &[Fr],
+    r_cycle_prime: &[Fr],
+    log_k: usize,
+) -> Result<Vec<NamedScalar<Fr>>, RuntimePlanError> {
+    let int_eval = IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime);
+    let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()];
+    let entry_address_eq =
+        EqPolynomial::<Fr>::try_mle_at_boolean_index(entry_bytecode_index, r_address_prime).ok_or(
+            RuntimePlanError::InvalidInputLength {
+                input: plan.entry_bytecode_index,
+                expected: 1usize.checked_shl(log_k as u32).unwrap_or(usize::MAX),
+                actual: entry_bytecode_index.saturating_add(1),
+            },
+        )?;
+
+    let mut output_terms = Vec::with_capacity(plan.output_terms.len());
+    for term in plan.output_terms {
+        let value = match *term {
+            Stage67BytecodeOutputTermPlan::StageValue {
+                symbol: _,
+                stage_index,
+                gamma_power,
+                identity_gamma_power,
+            } => {
+                let stage =
+                    plan.stages
+                        .get(stage_index)
+                        .ok_or(RuntimePlanError::InvalidInputLength {
+                            input: plan.entries,
+                            expected: stage_index + 1,
+                            actual: plan.stages.len(),
+                        })?;
+                let value = stage_value_evals.get(stage_index).copied().ok_or(
+                    RuntimePlanError::InvalidInputLength {
+                        input: plan.entries,
+                        expected: stage_index + 1,
+                        actual: stage_value_evals.len(),
+                    },
+                )?;
+                let cycle_point =
+                    stage67_bytecode_stage_cycle_point(store, stage, r_cycle_prime.len())?;
+                let identity_contrib = identity_gamma_power
+                    .map_or(Fr::from_u64(0), |power| gamma_powers[power] * int_eval);
+                (value + identity_contrib)
+                    * EqPolynomial::<Fr>::mle(&cycle_point, r_cycle_prime)
+                    * gamma_powers[gamma_power]
+            }
+            Stage67BytecodeOutputTermPlan::Entry {
+                symbol: _,
+                gamma_power,
+            } => {
+                gamma_powers[gamma_power]
+                    * entry_address_eq
+                    * EqPolynomial::<Fr>::mle(&zero_cycle, r_cycle_prime)
+            }
+        };
+        output_terms.push(NamedScalar {
+            symbol: (*term).symbol(),
+            value,
+        });
+    }
+    Ok(output_terms)
+}
+
+fn stage67_bytecode_stage_cycle_point(
+    store: &ValueStore<Fr>,
+    stage: &Stage67BytecodeStagePlan,
+    log_t: usize,
+) -> Result<Vec<Fr>, RuntimePlanError> {
+    suffix_point(
+        store_point(store, stage.cycle_point)?,
+        log_t,
+        stage.cycle_point,
+    )
+    .map(|point| point.to_vec())
+}
+
+fn stage67_bytecode_stage_value_evals<E: Stage67BytecodeEntry>(
+    plan: &Stage67BytecodeReadRafPlan,
+    entries: &[E],
+    entry_bytecode_index: usize,
+    num_lookup_tables: usize,
+    store: &ValueStore<Fr>,
+    r_address: &[Fr],
+    log_t: usize,
+) -> Result<Vec<Fr>, RuntimePlanError> {
+    let expected_len =
+        1usize
+            .checked_shl(r_address.len() as u32)
+            .ok_or(RuntimePlanError::InvalidInputLength {
+                input: plan.entries,
+                expected: usize::BITS as usize,
+                actual: r_address.len(),
+            })?;
+    if entries.len() != expected_len {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input: plan.entries,
+            expected: expected_len,
+            actual: entries.len(),
+        });
+    }
+    if entry_bytecode_index >= expected_len {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input: plan.entry_bytecode_index,
+            expected: expected_len,
+            actual: entry_bytecode_index + 1,
+        });
+    }
+
+    let stage_contexts = plan
+        .stages
+        .iter()
+        .map(|stage| {
+            Ok(Stage67BytecodeStageContext {
+                plan: stage,
+                gamma_powers: field_powers(
+                    store_scalar(store, stage.gamma)?,
+                    stage67_bytecode_stage_gamma_power_count(stage, num_lookup_tables),
+                ),
+                register_point: match stage.register_point {
+                    Some(symbol) => Some(stage67_register_prefix_point(store, symbol, log_t)?),
+                    None => None,
+                },
+            })
+        })
+        .collect::<Result<Vec<_>, RuntimePlanError>>()?;
+
+    let mut evals = vec![Fr::from_u64(0); plan.stages.len()];
+    for (index, entry) in entries.iter().enumerate() {
+        let eq = EqPolynomial::<Fr>::try_mle_at_boolean_index(index, r_address).ok_or(
+            RuntimePlanError::InvalidInputLength {
+                input: plan.entries,
+                expected: expected_len,
+                actual: index + 1,
+            },
+        )?;
+        let values = stage67_bytecode_entry_stage_values(plan, entry, &stage_contexts)?;
+        for stage in 0..evals.len() {
+            evals[stage] += eq * values[stage];
+        }
+    }
+    Ok(evals)
+}
+
+struct Stage67BytecodeStageContext<'a> {
+    plan: &'a Stage67BytecodeStagePlan,
+    gamma_powers: Vec<Fr>,
+    register_point: Option<&'a [Fr]>,
+}
+
+fn stage67_bytecode_entry_stage_values<E: Stage67BytecodeEntry>(
+    plan: &Stage67BytecodeReadRafPlan,
+    entry: &E,
+    stage_contexts: &[Stage67BytecodeStageContext<'_>],
+) -> Result<Vec<Fr>, RuntimePlanError> {
+    stage_contexts
+        .iter()
+        .map(|context| stage67_bytecode_entry_stage_value(plan, entry, context))
+        .collect()
+}
+
+fn stage67_bytecode_entry_stage_value<E: Stage67BytecodeEntry>(
+    plan: &Stage67BytecodeReadRafPlan,
+    entry: &E,
+    context: &Stage67BytecodeStageContext<'_>,
+) -> Result<Fr, RuntimePlanError> {
+    let mut value = Fr::from_u64(0);
+    for term in context.plan.terms {
+        value += match *term {
+            Stage67BytecodeTermPlan::Address { gamma_power } => {
+                entry.address() * context.gamma_powers[gamma_power]
+            }
+            Stage67BytecodeTermPlan::Imm { gamma_power } => {
+                entry.imm() * context.gamma_powers[gamma_power]
+            }
+            Stage67BytecodeTermPlan::CircuitFlag { index, gamma_power } => {
+                if entry.circuit_flags()[index] {
+                    context.gamma_powers[gamma_power]
+                } else {
+                    Fr::from_u64(0)
+                }
+            }
+            Stage67BytecodeTermPlan::EntryFlag {
+                flag,
+                expected,
+                gamma_power,
+            } => {
+                if stage67_bytecode_entry_flag(entry, flag) == expected {
+                    context.gamma_powers[gamma_power]
+                } else {
+                    Fr::from_u64(0)
+                }
+            }
+            Stage67BytecodeTermPlan::RegisterEq {
+                register,
+                gamma_power,
+            } => {
+                let register_point =
+                    context
+                        .register_point
+                        .ok_or(RuntimePlanError::MissingValue {
+                            symbol: context.plan.cycle_point,
+                        })?;
+                stage67_register_eq(
+                    stage67_bytecode_entry_register(entry, register),
+                    register_point,
+                    stage67_bytecode_register_symbol(plan, register),
+                )? * context.gamma_powers[gamma_power]
+            }
+            Stage67BytecodeTermPlan::LookupTable { gamma_base } => {
+                let Some(table) = entry.lookup_table() else {
+                    continue;
+                };
+                if table >= plan_lookup_table_count(context, gamma_base) {
+                    return Err(RuntimePlanError::InvalidInputLength {
+                        input: plan.entry_lookup_table,
+                        expected: plan_lookup_table_count(context, gamma_base),
+                        actual: table + 1,
+                    });
+                }
+                context.gamma_powers[gamma_base + table]
+            }
+        };
+    }
+    Ok(value)
+}
+
+fn stage67_bytecode_stage_gamma_power_count(
+    stage: &Stage67BytecodeStagePlan,
+    num_lookup_tables: usize,
+) -> usize {
+    stage
+        .terms
+        .iter()
+        .map(|term| match *term {
+            Stage67BytecodeTermPlan::Address { gamma_power }
+            | Stage67BytecodeTermPlan::Imm { gamma_power }
+            | Stage67BytecodeTermPlan::CircuitFlag { gamma_power, .. }
+            | Stage67BytecodeTermPlan::EntryFlag { gamma_power, .. }
+            | Stage67BytecodeTermPlan::RegisterEq { gamma_power, .. } => gamma_power + 1,
+            Stage67BytecodeTermPlan::LookupTable { gamma_base } => gamma_base + num_lookup_tables,
+        })
+        .max()
+        .unwrap_or(0)
+}
+
+fn plan_lookup_table_count(context: &Stage67BytecodeStageContext<'_>, gamma_base: usize) -> usize {
+    context.gamma_powers.len().saturating_sub(gamma_base)
+}
+
+fn stage67_bytecode_entry_flag<E: Stage67BytecodeEntry>(
+    entry: &E,
+    flag: Stage67BytecodeFlag,
+) -> bool {
+    match flag {
+        Stage67BytecodeFlag::IsInterleaved => entry.is_interleaved(),
+        Stage67BytecodeFlag::IsBranch => entry.is_branch(),
+        Stage67BytecodeFlag::LeftIsRs1 => entry.left_is_rs1(),
+        Stage67BytecodeFlag::LeftIsPc => entry.left_is_pc(),
+        Stage67BytecodeFlag::RightIsRs2 => entry.right_is_rs2(),
+        Stage67BytecodeFlag::RightIsImm => entry.right_is_imm(),
+        Stage67BytecodeFlag::IsNoop => entry.is_noop(),
+    }
+}
+
+fn stage67_bytecode_entry_register<E: Stage67BytecodeEntry>(
+    entry: &E,
+    register: Stage67BytecodeRegister,
+) -> Option<usize> {
+    match register {
+        Stage67BytecodeRegister::Rd => entry.rd(),
+        Stage67BytecodeRegister::Rs1 => entry.rs1(),
+        Stage67BytecodeRegister::Rs2 => entry.rs2(),
+    }
+}
+
+fn stage67_bytecode_register_symbol(
+    plan: &Stage67BytecodeReadRafPlan,
+    register: Stage67BytecodeRegister,
+) -> &'static str {
+    match register {
+        Stage67BytecodeRegister::Rd => plan.registers.rd,
+        Stage67BytecodeRegister::Rs1 => plan.registers.rs1,
+        Stage67BytecodeRegister::Rs2 => plan.registers.rs2,
+    }
+}
+
+fn stage67_register_eq(
+    index: Option<usize>,
+    point: &[Fr],
+    input: &'static str,
+) -> Result<Fr, RuntimePlanError> {
+    let Some(index) = index else {
+        return Ok(Fr::from_u64(0));
+    };
+    let register_count =
+        1usize
+            .checked_shl(point.len() as u32)
+            .ok_or(RuntimePlanError::InvalidInputLength {
+                input,
+                expected: usize::BITS as usize,
+                actual: point.len(),
+            })?;
+    if index >= register_count {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input,
+            expected: register_count,
+            actual: index + 1,
+        });
+    }
+    EqPolynomial::<Fr>::try_mle_at_boolean_index(index, point).ok_or(
+        RuntimePlanError::InvalidInputLength {
+            input,
+            expected: register_count,
+            actual: index + 1,
+        },
+    )
+}
+
+fn stage67_register_prefix_point<'a>(
+    store: &'a ValueStore<Fr>,
+    symbol: &'static str,
+    log_t: usize,
+) -> Result<&'a [Fr], RuntimePlanError> {
+    let point = store_point(store, symbol)?;
+    let register_len =
+        point
+            .len()
+            .checked_sub(log_t)
+            .ok_or(RuntimePlanError::InvalidInputLength {
+                input: symbol,
+                expected: log_t,
+                actual: point.len(),
+            })?;
+    prefix_point(point, register_len, symbol)
+}
+
+pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Result<Fr, RuntimePlanError> {
+    let stride_offset = usize::from(!left);
+    let operand_bits = point.len() / 2;
+    if point.len() != operand_bits * 2 {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input: "stage5.instruction_read_raf.operand_point",
+            expected: operand_bits * 2,
+            actual: point.len(),
+        });
+    }
+    IdentityPolynomial::new(operand_bits)
+        .try_evaluate_projected(point, stride_offset, 2)
+        .ok_or(RuntimePlanError::InvalidInputLength {
+            input: "stage5.instruction_read_raf.operand_point",
+            expected: operand_bits * 2,
+            actual: point.len(),
+        })
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_local_scalars.rs b/crates/bolt/src/protocols/jolt/verifier_local_scalars.rs
new file mode 100644
index 0000000000..b8359b76b5
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_local_scalars.rs
@@ -0,0 +1,52 @@
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct JoltLocalScalarEmitPlan {
+    pub(crate) symbol: String,
+    pub(crate) kind: JoltLocalScalarMleKind,
+}
+
+impl JoltLocalScalarEmitPlan {
+    pub(crate) fn is_lookup_table(&self) -> bool {
+        matches!(self.kind, JoltLocalScalarMleKind::LookupTable { .. })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum JoltLocalScalarMleKind {
+    LookupTable { index: usize },
+    LeftOperand,
+    RightOperand,
+    Identity,
+}
+
+pub(crate) fn emit_jolt_local_scalar_constants(
+    const_name: &str,
+    values: &[JoltLocalScalarEmitPlan],
+) -> String {
+    let values = values
+        .iter()
+        .map(|value| {
+            format!(
+                "    JoltLocalScalarPlan {{ symbol: {}, kind: {} }},",
+                rust_str(&value.symbol),
+                local_scalar_kind_expr(&value.kind),
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!("pub const {const_name}: &[JoltLocalScalarPlan] = &[\n{values}\n];\n\n")
+}
+
+fn local_scalar_kind_expr(kind: &JoltLocalScalarMleKind) -> String {
+    match kind {
+        JoltLocalScalarMleKind::LookupTable { index } => {
+            format!("JoltLocalScalarMleKind::LookupTable {{ index: {index} }}")
+        }
+        JoltLocalScalarMleKind::LeftOperand => "JoltLocalScalarMleKind::LeftOperand".to_owned(),
+        JoltLocalScalarMleKind::RightOperand => "JoltLocalScalarMleKind::RightOperand".to_owned(),
+        JoltLocalScalarMleKind::Identity => "JoltLocalScalarMleKind::Identity".to_owned(),
+    }
+}
+
+fn rust_str(value: &str) -> String {
+    format!("{value:?}")
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_opening_rows.rs b/crates/bolt/src/protocols/jolt/verifier_opening_rows.rs
new file mode 100644
index 0000000000..3cee4c8106
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_opening_rows.rs
@@ -0,0 +1,75 @@
+use melior::ir::OperationRef;
+
+use crate::emit::rust::EmitError;
+use crate::protocols::jolt::cpu_attrs::{
+    int_attr, operand_symbol, operand_symbols, string_attr, symbol_array_attr, symbol_attr,
+};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuOpeningClaimPlan {
+    pub symbol: String,
+    pub oracle: String,
+    pub domain: String,
+    pub point_arity: usize,
+    pub claim_kind: String,
+    pub point_source: String,
+    pub eval_source: String,
+}
+
+impl CpuOpeningClaimPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            oracle: symbol_attr(operation, "oracle")?,
+            domain: symbol_attr(operation, "domain")?,
+            point_arity: int_attr(operation, "point_arity")?,
+            claim_kind: string_attr(operation, "claim_kind")?,
+            point_source: operand_symbol(operation, 0)?,
+            eval_source: operand_symbol(operation, 1)?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuOpeningClaimEqualityPlan {
+    pub symbol: String,
+    pub mode: String,
+    pub lhs: String,
+    pub rhs: String,
+}
+
+impl CpuOpeningClaimEqualityPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            mode: string_attr(operation, "mode")?,
+            lhs: operand_symbol(operation, 0)?,
+            rhs: operand_symbol(operation, 1)?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuOpeningBatchPlan {
+    pub symbol: String,
+    pub stage: String,
+    pub proof_slot: String,
+    pub policy: String,
+    pub count: usize,
+    pub ordered_claims: Vec<String>,
+    pub claim_operands: Vec<String>,
+}
+
+impl CpuOpeningBatchPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            stage: symbol_attr(operation, "stage")?,
+            proof_slot: symbol_attr(operation, "proof_slot")?,
+            policy: string_attr(operation, "policy")?,
+            count: int_attr(operation, "count")?,
+            ordered_claims: symbol_array_attr(operation, "ordered_claims")?,
+            claim_operands: operand_symbols(operation, 0)?,
+        })
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs
new file mode 100644
index 0000000000..5bd58a3754
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs
@@ -0,0 +1,2854 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::fmt::Write as _;
+
+use crate::emit::rust::EmitError;
+use crate::protocols::jolt::rust_target_plan::{
+    ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, ProgramStepKind,
+    RustTargetPlanError, ScalarExprKind, SumcheckPointOrder, TranscriptSqueezeKind,
+};
+use crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan;
+use crate::protocols::jolt::stage6_bytecode_read_raf_plan::Stage6BytecodeReadRafEmitPlan;
+use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan;
+use crate::protocols::jolt::verifier_opening_rows::{
+    CpuOpeningBatchPlan, CpuOpeningClaimEqualityPlan, CpuOpeningClaimPlan,
+};
+use crate::protocols::jolt::verifier_point_rows::{
+    CpuPointConcatPlan, CpuPointSlicePlan, CpuPointZeroPlan,
+};
+use crate::protocols::jolt::verifier_program_rows::{
+    CpuOpeningInputPlan, CpuProgramStepPlan, CpuTranscriptAbsorbBytesPlan, CpuTranscriptSqueezePlan,
+};
+use crate::protocols::jolt::verifier_relation_outputs::{
+    self, RelationOutputEvalFamilyPlan, RelationOutputFunctionFamilyPlan, RelationOutputPlan,
+    RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan,
+};
+use crate::protocols::jolt::verifier_sumcheck_rows::{
+    CpuSumcheckBatchPlan, CpuSumcheckClaimPlan, CpuSumcheckDriverPlan, CpuSumcheckEvalPlan,
+    CpuSumcheckInstanceResultPlan,
+};
+use crate::protocols::jolt::verifier_value_rows::{
+    CpuFieldConstantPlan, CpuFieldExprPlan, CpuScalarExprPlan,
+};
+use crate::protocols::jolt::verifier_values::{
+    VerifierFieldVectorValueKind, VerifierFieldVectorValueRef, VerifierFieldVectorValueSet,
+    VerifierPointValueKind, VerifierPointValueRef, VerifierPointValueSet, VerifierScalarSourceSet,
+    VerifierScalarValueKind, VerifierScalarValuePlan, VerifierScalarValueRef,
+    VerifierScalarValueSet,
+};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierProgramStepPlan {
+    pub(crate) kind: ProgramStepKind,
+    pub(crate) symbol: String,
+}
+
+impl VerifierProgramStepPlan {
+    pub(crate) fn from_cpu(kind: &str, symbol: &str) -> Result<Self, EmitError> {
+        Ok(Self {
+            kind: ProgramStepKind::from_cpu_attr(kind).map_err(plan_error)?,
+            symbol: symbol.to_owned(),
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierTranscriptSqueezePlan {
+    pub(crate) symbol: String,
+    pub(crate) label: String,
+    pub(crate) kind: TranscriptSqueezeKind,
+    pub(crate) count: usize,
+}
+
+impl VerifierTranscriptSqueezePlan {
+    pub(crate) fn from_cpu(
+        symbol: &str,
+        label: &str,
+        kind: &str,
+        count: usize,
+    ) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: symbol.to_owned(),
+            label: label.to_owned(),
+            kind: TranscriptSqueezeKind::from_cpu_attr(kind).map_err(plan_error)?,
+            count,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierTranscriptAbsorbBytesPlan {
+    pub(crate) symbol: String,
+    pub(crate) label: String,
+    pub(crate) payload: String,
+}
+
+impl VerifierTranscriptAbsorbBytesPlan {
+    pub(crate) fn from_cpu(symbol: &str, label: &str, payload: &str) -> Self {
+        Self {
+            symbol: symbol.to_owned(),
+            label: label.to_owned(),
+            payload: payload.to_owned(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierOpeningInputPlan {
+    pub(crate) symbol: String,
+    pub(crate) source_stage: String,
+    pub(crate) source_claim: String,
+    pub(crate) oracle: String,
+    pub(crate) domain: String,
+    pub(crate) point_arity: usize,
+    pub(crate) claim_kind: ClaimKind,
+}
+
+impl VerifierOpeningInputPlan {
+    pub(crate) fn from_cpu(
+        symbol: &str,
+        source_stage: &str,
+        source_claim: &str,
+        oracle: &str,
+        domain: &str,
+        point_arity: usize,
+        claim_kind: &str,
+    ) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: symbol.to_owned(),
+            source_stage: source_stage.to_owned(),
+            source_claim: source_claim.to_owned(),
+            oracle: oracle.to_owned(),
+            domain: domain.to_owned(),
+            point_arity,
+            claim_kind: ClaimKind::from_cpu_attr(claim_kind).map_err(plan_error)?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierFieldConstantPlan {
+    pub(crate) symbol: String,
+    pub(crate) field: String,
+    pub(crate) value: usize,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierFieldExprPlan {
+    pub(crate) symbol: String,
+    pub(crate) kind: FieldExprKind,
+    pub(crate) operands: Vec<VerifierScalarValueRef>,
+}
+
+impl VerifierFieldExprPlan {
+    pub(crate) fn from_cpu(
+        symbol: &str,
+        formula: &str,
+        operands: &[String],
+    ) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: symbol.to_owned(),
+            kind: FieldExprKind::from_cpu_attr(formula).map_err(plan_error)?,
+            operands: operands
+                .iter()
+                .map(|operand| VerifierScalarValueRef::new(operand.as_str()))
+                .collect(),
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierScalarExprPlan {
+    pub(crate) symbol: String,
+    pub(crate) kind: ScalarExprKind,
+    pub(crate) operands: Vec<VerifierScalarExprOperand>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum VerifierScalarExprOperand {
+    Field(VerifierScalarValueRef),
+    FieldVector(VerifierFieldVectorValueRef),
+    Point(VerifierPointValueRef),
+}
+
+impl VerifierScalarExprOperand {
+    pub(crate) fn symbol(&self) -> &str {
+        match self {
+            Self::Field(value_ref) => value_ref.symbol(),
+            Self::FieldVector(value_ref) => value_ref.symbol(),
+            Self::Point(value_ref) => value_ref.symbol(),
+        }
+    }
+}
+
+impl VerifierScalarExprPlan {
+    pub(crate) fn from_cpu(
+        symbol: &str,
+        formula: &str,
+        operands: &[String],
+    ) -> Result<Self, EmitError> {
+        let kind = ScalarExprKind::from_cpu_attr(formula).map_err(plan_error)?;
+        Ok(Self {
+            symbol: symbol.to_owned(),
+            operands: scalar_expr_operands(symbol, &kind, operands)?,
+            kind,
+        })
+    }
+}
+
+fn scalar_expr_operands(
+    symbol: &str,
+    kind: &ScalarExprKind,
+    operands: &[String],
+) -> Result<Vec<VerifierScalarExprOperand>, EmitError> {
+    match kind {
+        ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => {
+            verify_plan_operand_count("field-vector scalar expr", symbol, 1, operands.len())?;
+            Ok(operands
+                .iter()
+                .map(|operand| {
+                    VerifierScalarExprOperand::FieldVector(VerifierFieldVectorValueRef::new(
+                        operand.as_str(),
+                    ))
+                })
+                .collect())
+        }
+        ScalarExprKind::PowerStridedWeightedSum { .. } => Ok(operands
+            .iter()
+            .map(|operand| {
+                VerifierScalarExprOperand::Field(VerifierScalarValueRef::new(operand.as_str()))
+            })
+            .collect()),
+        ScalarExprKind::StructuredPolynomial { .. } => {
+            verify_plan_operand_count(
+                "structured polynomial scalar expr",
+                symbol,
+                2,
+                operands.len(),
+            )?;
+            Ok(operands
+                .iter()
+                .map(|operand| {
+                    VerifierScalarExprOperand::Point(VerifierPointValueRef::new(operand.as_str()))
+                })
+                .collect())
+        }
+        ScalarExprKind::PointElement { .. } => {
+            verify_plan_operand_count("point element scalar expr", symbol, 1, operands.len())?;
+            Ok(operands
+                .iter()
+                .map(|operand| {
+                    VerifierScalarExprOperand::Point(VerifierPointValueRef::new(operand.as_str()))
+                })
+                .collect())
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierSumcheckEvalPlan {
+    pub(crate) symbol: String,
+    pub(crate) source: String,
+    pub(crate) name: String,
+    pub(crate) index: usize,
+    pub(crate) oracle: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierSumcheckClaimPlan {
+    pub(crate) symbol: String,
+    pub(crate) stage: String,
+    pub(crate) domain: String,
+    pub(crate) num_rounds: usize,
+    pub(crate) degree: usize,
+    pub(crate) claim: String,
+    pub(crate) relation: JoltVerifierRelationKind,
+    pub(crate) claim_value: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierSumcheckBatchPlan {
+    pub(crate) symbol: String,
+    pub(crate) stage: String,
+    pub(crate) proof_slot: String,
+    pub(crate) policy: String,
+    pub(crate) count: usize,
+    pub(crate) claim_operands: Vec<String>,
+    pub(crate) claim_label: String,
+    pub(crate) round_label: String,
+    pub(crate) round_schedule: Vec<usize>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierSumcheckDriverPlan {
+    pub(crate) symbol: String,
+    pub(crate) stage: String,
+    pub(crate) proof_slot: String,
+    pub(crate) relation: JoltVerifierRelationKind,
+    pub(crate) batch: String,
+    pub(crate) policy: String,
+    pub(crate) round_schedule: Vec<usize>,
+    pub(crate) claim_label: String,
+    pub(crate) round_label: String,
+    pub(crate) num_rounds: usize,
+    pub(crate) degree: usize,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierSumcheckInstanceResultPlan {
+    pub(crate) symbol: String,
+    pub(crate) source: String,
+    pub(crate) claim: String,
+    pub(crate) relation: JoltVerifierRelationKind,
+    pub(crate) index: usize,
+    pub(crate) point_arity: usize,
+    pub(crate) num_rounds: usize,
+    pub(crate) round_offset: usize,
+    pub(crate) point_order: SumcheckPointOrder,
+    pub(crate) degree: usize,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum VerifierPointExprKind {
+    Zero { field: String, arity: usize },
+    Slice { offset: usize, length: usize },
+    Concat { layout: String, arity: usize },
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierPointExprPlan {
+    pub(crate) symbol: String,
+    pub(crate) kind: VerifierPointExprKind,
+    pub(crate) operands: Vec<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierOpeningClaimPlan {
+    pub(crate) symbol: String,
+    pub(crate) oracle: String,
+    pub(crate) domain: String,
+    pub(crate) point_arity: usize,
+    pub(crate) claim_kind: ClaimKind,
+    pub(crate) point_source: String,
+    pub(crate) eval_source: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierOpeningClaimEqualityPlan {
+    pub(crate) symbol: String,
+    pub(crate) mode: OpeningEqualityMode,
+    pub(crate) lhs: String,
+    pub(crate) rhs: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierOpeningBatchPlan {
+    pub(crate) symbol: String,
+    pub(crate) stage: String,
+    pub(crate) proof_slot: String,
+    pub(crate) policy: String,
+    pub(crate) count: usize,
+    pub(crate) ordered_claims: Vec<String>,
+    pub(crate) claim_operands: Vec<String>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum VerifierRelationLocalInputKind {
+    Stage5InstructionReadRaf,
+    Stage6BytecodeReadRaf,
+}
+
+impl VerifierRelationLocalInputKind {
+    fn label(self) -> &'static str {
+        match self {
+            Self::Stage5InstructionReadRaf => "Stage 5 instruction read-RAF",
+            Self::Stage6BytecodeReadRaf => "Stage 6 bytecode read-RAF",
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum VerifierRelationLocalInputPlan {
+    Stage5InstructionReadRaf(Stage5InstructionReadRafEmitPlan),
+    Stage6BytecodeReadRaf(Stage6BytecodeReadRafEmitPlan),
+}
+
+impl VerifierRelationLocalInputPlan {
+    fn kind(&self) -> VerifierRelationLocalInputKind {
+        match self {
+            Self::Stage5InstructionReadRaf(_) => {
+                VerifierRelationLocalInputKind::Stage5InstructionReadRaf
+            }
+            Self::Stage6BytecodeReadRaf(_) => VerifierRelationLocalInputKind::Stage6BytecodeReadRaf,
+        }
+    }
+
+    fn extend_scalar_value_plans(&self, values: &mut Vec<VerifierScalarValuePlan>) {
+        match self {
+            Self::Stage5InstructionReadRaf(plan) => {
+                values.extend(plan.local_scalar_symbols().map(|symbol| {
+                    VerifierScalarValuePlan::new(
+                        symbol.clone(),
+                        VerifierScalarValueKind::RelationOutputLocal,
+                    )
+                }));
+            }
+            Self::Stage6BytecodeReadRaf(_) => {
+                for symbol in Stage6BytecodeReadRafEmitPlan::local_scalar_symbols() {
+                    values.push(VerifierScalarValuePlan::new(
+                        symbol,
+                        VerifierScalarValueKind::RelationOutputLocal,
+                    ));
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub(crate) struct VerifierRelationLocalInputPlans {
+    rows: Vec<VerifierRelationLocalInputPlan>,
+}
+
+impl VerifierRelationLocalInputPlans {
+    pub(crate) fn add_stage5_instruction_read_raf(
+        &mut self,
+        plan: Stage5InstructionReadRafEmitPlan,
+    ) -> Result<(), EmitError> {
+        self.push(VerifierRelationLocalInputPlan::Stage5InstructionReadRaf(
+            plan,
+        ))
+    }
+
+    pub(crate) fn stage5_instruction_read_raf(
+        &self,
+    ) -> Result<&Stage5InstructionReadRafEmitPlan, EmitError> {
+        self.rows
+            .iter()
+            .find_map(|row| match row {
+                VerifierRelationLocalInputPlan::Stage5InstructionReadRaf(plan) => Some(plan),
+                VerifierRelationLocalInputPlan::Stage6BytecodeReadRaf(_) => None,
+            })
+            .ok_or_else(|| EmitError::new("missing Stage 5 instruction read-RAF local-input plan"))
+    }
+
+    pub(crate) fn add_stage6_bytecode_read_raf(
+        &mut self,
+        plan: Stage6BytecodeReadRafEmitPlan,
+    ) -> Result<(), EmitError> {
+        self.push(VerifierRelationLocalInputPlan::Stage6BytecodeReadRaf(plan))
+    }
+
+    pub(crate) fn stage6_bytecode_read_raf(
+        &self,
+    ) -> Result<&Stage6BytecodeReadRafEmitPlan, EmitError> {
+        self.rows
+            .iter()
+            .find_map(|row| match row {
+                VerifierRelationLocalInputPlan::Stage5InstructionReadRaf(_) => None,
+                VerifierRelationLocalInputPlan::Stage6BytecodeReadRaf(plan) => Some(plan),
+            })
+            .ok_or_else(|| EmitError::new("missing Stage 6 bytecode read-RAF local-input plan"))
+    }
+
+    fn push(&mut self, row: VerifierRelationLocalInputPlan) -> Result<(), EmitError> {
+        let kind = row.kind();
+        if self.rows.iter().any(|existing| existing.kind() == kind) {
+            return Err(EmitError::new(format!(
+                "duplicate {} local-input plan",
+                kind.label()
+            )));
+        }
+        self.rows.push(row);
+        Ok(())
+    }
+
+    fn extend_scalar_value_plans(&self, values: &mut Vec<VerifierScalarValuePlan>) {
+        for row in &self.rows {
+            row.extend_scalar_value_plans(values);
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub(crate) struct VerifierStagePlan {
+    pub(crate) steps: Vec<VerifierProgramStepPlan>,
+    pub(crate) transcript_squeezes: Vec<VerifierTranscriptSqueezePlan>,
+    pub(crate) transcript_absorb_bytes: Vec<VerifierTranscriptAbsorbBytesPlan>,
+    pub(crate) opening_inputs: Vec<VerifierOpeningInputPlan>,
+    pub(crate) field_constants: Vec<VerifierFieldConstantPlan>,
+    pub(crate) field_exprs: Vec<VerifierFieldExprPlan>,
+    pub(crate) scalar_exprs: Vec<VerifierScalarExprPlan>,
+    pub(crate) claims: Vec<VerifierSumcheckClaimPlan>,
+    pub(crate) batches: Vec<VerifierSumcheckBatchPlan>,
+    pub(crate) drivers: Vec<VerifierSumcheckDriverPlan>,
+    pub(crate) instance_results: Vec<VerifierSumcheckInstanceResultPlan>,
+    pub(crate) sumcheck_evals: Vec<VerifierSumcheckEvalPlan>,
+    pub(crate) indexed_eval_families: Vec<IndexedEvalFamilyPlan>,
+    pub(crate) relation_output_values: Vec<StructuredPolynomialEvalPlan>,
+    pub(crate) relation_output_eval_families: Vec<RelationOutputEvalFamilyPlan>,
+    pub(crate) relation_output_product_families: Vec<RelationOutputProductFamilyPlan>,
+    pub(crate) relation_output_function_families: Vec<RelationOutputFunctionFamilyPlan>,
+    pub(crate) relation_outputs: Vec<RelationOutputPlan>,
+    pub(crate) relation_local_inputs: VerifierRelationLocalInputPlans,
+    pub(crate) point_exprs: Vec<VerifierPointExprPlan>,
+    pub(crate) opening_claims: Vec<VerifierOpeningClaimPlan>,
+    pub(crate) opening_equalities: Vec<VerifierOpeningClaimEqualityPlan>,
+    pub(crate) opening_batches: Vec<VerifierOpeningBatchPlan>,
+}
+
+impl VerifierStagePlan {
+    pub(crate) fn scalar_value_plans(&self) -> Vec<VerifierScalarValuePlan> {
+        let mut values = Vec::new();
+        values.extend(self.opening_inputs.iter().map(|input| {
+            VerifierScalarValuePlan::new(&input.symbol, VerifierScalarValueKind::OpeningInput)
+        }));
+        values.extend(self.field_constants.iter().map(|constant| {
+            VerifierScalarValuePlan::new(&constant.symbol, VerifierScalarValueKind::FieldConstant)
+        }));
+        values.extend(
+            self.transcript_squeezes
+                .iter()
+                .filter(|squeeze| {
+                    matches!(
+                        squeeze.kind,
+                        TranscriptSqueezeKind::ChallengeScalar | TranscriptSqueezeKind::Scalar
+                    )
+                })
+                .map(|squeeze| {
+                    VerifierScalarValuePlan::new(
+                        &squeeze.symbol,
+                        VerifierScalarValueKind::TranscriptScalar,
+                    )
+                }),
+        );
+        values.extend(self.relation_output_values.iter().map(|value| {
+            VerifierScalarValuePlan::new(
+                &value.symbol,
+                VerifierScalarValueKind::StructuredPolynomialEval,
+            )
+        }));
+        values.extend(self.relation_output_eval_families.iter().map(|family| {
+            VerifierScalarValuePlan::new(&family.symbol, VerifierScalarValueKind::OutputEvalFamily)
+        }));
+        values.extend(self.relation_output_product_families.iter().map(|family| {
+            VerifierScalarValuePlan::new(
+                &family.symbol,
+                VerifierScalarValueKind::OutputProductFamily,
+            )
+        }));
+        values.extend(self.relation_output_function_families.iter().map(|family| {
+            VerifierScalarValuePlan::new(
+                &family.symbol,
+                VerifierScalarValueKind::OutputFunctionFamily,
+            )
+        }));
+        values.extend(
+            self.relation_outputs
+                .iter()
+                .flat_map(|output| output.local_scalar_symbols())
+                .map(|symbol| {
+                    VerifierScalarValuePlan::new(
+                        symbol.clone(),
+                        VerifierScalarValueKind::RelationOutputLocal,
+                    )
+                }),
+        );
+        values.extend(self.field_exprs.iter().map(|expr| {
+            VerifierScalarValuePlan::new(&expr.symbol, VerifierScalarValueKind::FieldExpr)
+        }));
+        let structured_eval_symbols = self
+            .relation_output_values
+            .iter()
+            .map(|value| value.symbol.as_str())
+            .collect::<BTreeSet<_>>();
+        values.extend(self.scalar_exprs.iter().filter_map(|expr| {
+            if matches!(expr.kind, ScalarExprKind::StructuredPolynomial { .. }) {
+                if structured_eval_symbols.contains(expr.symbol.as_str()) {
+                    return None;
+                }
+                return Some(VerifierScalarValuePlan::new(
+                    &expr.symbol,
+                    VerifierScalarValueKind::StructuredPolynomialEval,
+                ));
+            }
+            Some(VerifierScalarValuePlan::new(
+                &expr.symbol,
+                VerifierScalarValueKind::ScalarExpr,
+            ))
+        }));
+        self.relation_local_inputs
+            .extend_scalar_value_plans(&mut values);
+        values.extend(self.sumcheck_evals.iter().map(|eval| {
+            VerifierScalarValuePlan::new(&eval.symbol, VerifierScalarValueKind::SumcheckEval)
+        }));
+        values
+    }
+
+    pub(crate) fn scalar_values(&self) -> VerifierScalarValueSet {
+        let mut values = VerifierScalarValueSet::default();
+        let plans = self.scalar_value_plans();
+        values.extend_plans(&plans);
+        values
+    }
+
+    pub(crate) fn scalar_value_sources(&self) -> VerifierScalarSourceSet {
+        self.scalar_values().source_set()
+    }
+
+    pub(crate) fn field_vector_values(&self) -> VerifierFieldVectorValueSet {
+        let mut values = VerifierFieldVectorValueSet::default();
+        for family in &self.indexed_eval_families {
+            values.insert(
+                &family.symbol,
+                VerifierFieldVectorValueKind::IndexedEvalFamily,
+            );
+        }
+        values
+    }
+
+    pub(crate) fn point_values(&self) -> VerifierPointValueSet {
+        let mut values = VerifierPointValueSet::default();
+        for instance in &self.instance_results {
+            values.insert(&instance.symbol, VerifierPointValueKind::SumcheckInstance);
+        }
+        for input in &self.opening_inputs {
+            values.insert(&input.symbol, VerifierPointValueKind::OpeningInput);
+        }
+        for expr in &self.point_exprs {
+            values.insert(&expr.symbol, VerifierPointValueKind::PointExpr);
+        }
+        values
+    }
+
+    pub(crate) fn verify_sumcheck_flow(&self, stage: &str) -> Result<(), EmitError> {
+        let claims = self
+            .claims
+            .iter()
+            .map(|claim| claim.symbol.as_str())
+            .collect::<BTreeSet<_>>();
+        for batch in &self.batches {
+            verify_plan_count(
+                "sumcheck batch",
+                &batch.symbol,
+                batch.count,
+                batch.claim_operands.len(),
+            )?;
+            for claim in &batch.claim_operands {
+                if !claims.contains(claim.as_str()) {
+                    return Err(EmitError::new(format!(
+                        "{stage} sumcheck batch @{} references missing claim @{claim}",
+                        batch.symbol
+                    )));
+                }
+            }
+        }
+        let batches: BTreeMap<_, _> = self
+            .batches
+            .iter()
+            .map(|batch| (batch.symbol.as_str(), batch))
+            .collect();
+        for driver in &self.drivers {
+            let batch = batches.get(driver.batch.as_str()).ok_or_else(|| {
+                EmitError::new(format!(
+                    "{stage} sumcheck driver @{} references missing batch @{}",
+                    driver.symbol, driver.batch
+                ))
+            })?;
+            verify_plan_count(
+                "sumcheck driver round_schedule",
+                &driver.symbol,
+                driver.num_rounds,
+                driver.round_schedule.iter().sum(),
+            )?;
+            if driver.round_schedule != batch.round_schedule {
+                return Err(EmitError::new(format!(
+                    "{stage} sumcheck driver @{} round_schedule differs from batch @{}",
+                    driver.symbol, batch.symbol
+                )));
+            }
+        }
+        for instance in &self.instance_results {
+            if !claims.contains(instance.claim.as_str()) {
+                return Err(EmitError::new(format!(
+                    "{stage} sumcheck instance result @{} references missing claim @{}",
+                    instance.symbol, instance.claim
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn verify_relation_outputs(&self, stage: &str) -> Result<(), EmitError> {
+        let relations = self
+            .instance_results
+            .iter()
+            .map(|instance| instance.relation)
+            .collect::<BTreeSet<_>>();
+        let field_values = self.scalar_values();
+        let field_vector_values = self.field_vector_values();
+        let point_values = self.point_values();
+        verifier_relation_outputs::verify_relation_outputs(
+            stage,
+            verifier_relation_outputs::RelationOutputVerification {
+                relation_output_values: &self.relation_output_values,
+                relation_output_eval_families: &self.relation_output_eval_families,
+                relation_output_product_families: &self.relation_output_product_families,
+                relation_output_function_families: &self.relation_output_function_families,
+                relation_outputs: &self.relation_outputs,
+                relations: &relations,
+                field_values: &field_values,
+                field_vector_values: &field_vector_values,
+                point_values: &point_values,
+            },
+        )
+    }
+
+    pub(crate) fn verify_opening_flow(&self, stage: &str) -> Result<(), EmitError> {
+        let point_sources = self.opening_point_sources();
+        for expr in &self.point_exprs {
+            if let VerifierPointExprKind::Zero { field, .. } = &expr.kind {
+                if field != "bn254_fr" {
+                    return Err(EmitError::new(format!(
+                        "{stage} point expr @{} has unsupported zero field `{field}`",
+                        expr.symbol
+                    )));
+                }
+            }
+            for input in &expr.operands {
+                if !point_sources.contains(input) {
+                    return Err(EmitError::new(format!(
+                        "{stage} point expr @{} uses missing point source @{input}",
+                        expr.symbol
+                    )));
+                }
+            }
+        }
+
+        let mut opening_sources = self
+            .opening_inputs
+            .iter()
+            .map(|input| input.symbol.as_str())
+            .collect::<BTreeSet<_>>();
+        opening_sources.extend(
+            self.opening_claims
+                .iter()
+                .map(|claim| claim.symbol.as_str()),
+        );
+        for equality in &self.opening_equalities {
+            if !opening_sources.contains(equality.lhs.as_str()) {
+                return Err(EmitError::new(format!(
+                    "{stage} opening equality @{} uses missing lhs opening @{}",
+                    equality.symbol, equality.lhs
+                )));
+            }
+            if !opening_sources.contains(equality.rhs.as_str()) {
+                return Err(EmitError::new(format!(
+                    "{stage} opening equality @{} uses missing rhs opening @{}",
+                    equality.symbol, equality.rhs
+                )));
+            }
+        }
+
+        let drivers = self
+            .drivers
+            .iter()
+            .map(|driver| driver.symbol.as_str())
+            .collect::<BTreeSet<_>>();
+        for instance in &self.instance_results {
+            if !drivers.contains(instance.source.as_str()) {
+                return Err(EmitError::new(format!(
+                    "{stage} sumcheck instance result @{} references missing driver @{}",
+                    instance.symbol, instance.source
+                )));
+            }
+        }
+        for eval in &self.sumcheck_evals {
+            if !drivers.contains(eval.source.as_str()) {
+                return Err(EmitError::new(format!(
+                    "{stage} sumcheck eval @{} references missing driver @{}",
+                    eval.symbol, eval.source
+                )));
+            }
+        }
+
+        let eval_sources = self.scalar_value_sources();
+        for claim in &self.opening_claims {
+            if !point_sources.contains(&claim.point_source) {
+                return Err(EmitError::new(format!(
+                    "{stage} opening claim @{} uses missing point source @{}",
+                    claim.symbol, claim.point_source
+                )));
+            }
+            if !eval_sources.contains(&claim.eval_source) {
+                return Err(EmitError::new(format!(
+                    "{stage} opening claim @{} uses missing eval source @{}",
+                    claim.symbol, claim.eval_source
+                )));
+            }
+        }
+
+        let openings = self
+            .opening_claims
+            .iter()
+            .map(|claim| claim.symbol.as_str())
+            .collect::<BTreeSet<_>>();
+        for batch in &self.opening_batches {
+            verify_plan_count(
+                "opening batch",
+                &batch.symbol,
+                batch.count,
+                batch.ordered_claims.len(),
+            )?;
+            verify_plan_count(
+                "opening batch operands",
+                &batch.symbol,
+                batch.count,
+                batch.claim_operands.len(),
+            )?;
+            if batch.ordered_claims != batch.claim_operands {
+                return Err(EmitError::new(format!(
+                    "{stage} opening batch @{} operand order does not match ordered_claims",
+                    batch.symbol
+                )));
+            }
+            for claim in &batch.ordered_claims {
+                if !openings.contains(claim.as_str()) {
+                    return Err(EmitError::new(format!(
+                        "{stage} opening batch @{} references missing opening @{claim}",
+                        batch.symbol
+                    )));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn opening_point_sources(&self) -> BTreeSet<String> {
+        let mut values = BTreeSet::new();
+        values.extend(self.drivers.iter().map(|driver| driver.symbol.clone()));
+        values.extend(
+            self.instance_results
+                .iter()
+                .map(|instance| instance.symbol.clone()),
+        );
+        values.extend(self.opening_inputs.iter().map(|input| input.symbol.clone()));
+        values.extend(self.point_exprs.iter().map(|expr| expr.symbol.clone()));
+        values
+    }
+}
+
+pub(crate) trait VerifierProgramStepSource {
+    fn kind(&self) -> &str;
+    fn symbol(&self) -> &str;
+}
+
+pub(crate) trait VerifierTranscriptSqueezeSource {
+    fn symbol(&self) -> &str;
+    fn label(&self) -> &str;
+    fn kind(&self) -> &str;
+    fn count(&self) -> usize;
+}
+
+pub(crate) trait VerifierTranscriptAbsorbBytesSource {
+    fn symbol(&self) -> &str;
+    fn label(&self) -> &str;
+    fn payload(&self) -> &str;
+}
+
+pub(crate) trait VerifierOpeningInputSource {
+    fn symbol(&self) -> &str;
+    fn source_stage(&self) -> &str;
+    fn source_claim(&self) -> &str;
+    fn oracle(&self) -> &str;
+    fn domain(&self) -> &str;
+    fn point_arity(&self) -> usize;
+    fn claim_kind(&self) -> &str;
+}
+
+pub(crate) trait VerifierFieldConstantSource {
+    fn symbol(&self) -> &str;
+    fn field(&self) -> &str;
+    fn value(&self) -> usize;
+}
+
+pub(crate) trait VerifierFieldExprSource {
+    fn symbol(&self) -> &str;
+    fn formula(&self) -> &str;
+    fn operands(&self) -> &[String];
+}
+
+pub(crate) trait VerifierScalarExprSource {
+    fn symbol(&self) -> &str;
+    fn formula(&self) -> &str;
+    fn operands(&self) -> &[String];
+}
+
+pub(crate) trait VerifierSumcheckEvalSource {
+    fn symbol(&self) -> &str;
+    fn source(&self) -> &str;
+    fn name(&self) -> &str;
+    fn index(&self) -> usize;
+    fn oracle(&self) -> &str;
+}
+
+pub(crate) trait VerifierSumcheckClaimSource {
+    fn symbol(&self) -> &str;
+    fn stage(&self) -> &str;
+    fn domain(&self) -> &str;
+    fn num_rounds(&self) -> usize;
+    fn degree(&self) -> usize;
+    fn claim(&self) -> &str;
+    fn relation(&self) -> Option<&str>;
+    fn claim_value(&self) -> &str;
+}
+
+pub(crate) trait VerifierSumcheckBatchSource {
+    fn symbol(&self) -> &str;
+    fn stage(&self) -> &str;
+    fn proof_slot(&self) -> &str;
+    fn policy(&self) -> &str;
+    fn count(&self) -> usize;
+    fn claim_operands(&self) -> &[String];
+    fn claim_label(&self) -> &str;
+    fn round_label(&self) -> &str;
+    fn round_schedule(&self) -> &[usize];
+}
+
+pub(crate) trait VerifierSumcheckDriverSource {
+    fn symbol(&self) -> &str;
+    fn stage(&self) -> &str;
+    fn proof_slot(&self) -> &str;
+    fn relation(&self) -> Option<&str>;
+    fn batch(&self) -> &str;
+    fn policy(&self) -> &str;
+    fn round_schedule(&self) -> &[usize];
+    fn claim_label(&self) -> &str;
+    fn round_label(&self) -> &str;
+    fn num_rounds(&self) -> usize;
+    fn degree(&self) -> usize;
+}
+
+pub(crate) trait VerifierSumcheckInstanceResultSource {
+    fn symbol(&self) -> &str;
+    fn source(&self) -> &str;
+    fn claim(&self) -> &str;
+    fn relation(&self) -> &str;
+    fn index(&self) -> usize;
+    fn point_arity(&self) -> usize;
+    fn num_rounds(&self) -> usize;
+    fn round_offset(&self) -> usize;
+    fn point_order(&self) -> &str;
+    fn degree(&self) -> usize;
+}
+
+pub(crate) trait VerifierPointZeroSource {
+    fn symbol(&self) -> &str;
+    fn field(&self) -> &str;
+    fn arity(&self) -> usize;
+}
+
+pub(crate) trait VerifierPointSliceSource {
+    fn symbol(&self) -> &str;
+    fn offset(&self) -> usize;
+    fn length(&self) -> usize;
+    fn input(&self) -> &str;
+}
+
+pub(crate) trait VerifierPointConcatSource {
+    fn symbol(&self) -> &str;
+    fn layout(&self) -> &str;
+    fn arity(&self) -> usize;
+    fn inputs(&self) -> &[String];
+}
+
+pub(crate) trait VerifierOpeningClaimSource {
+    fn symbol(&self) -> &str;
+    fn oracle(&self) -> &str;
+    fn domain(&self) -> &str;
+    fn point_arity(&self) -> usize;
+    fn claim_kind(&self) -> &str;
+    fn point_source(&self) -> &str;
+    fn eval_source(&self) -> &str;
+}
+
+pub(crate) trait VerifierOpeningClaimEqualitySource {
+    fn symbol(&self) -> &str;
+    fn mode(&self) -> &str;
+    fn lhs(&self) -> &str;
+    fn rhs(&self) -> &str;
+}
+
+pub(crate) trait VerifierOpeningBatchSource {
+    fn symbol(&self) -> &str;
+    fn stage(&self) -> &str;
+    fn proof_slot(&self) -> &str;
+    fn policy(&self) -> &str;
+    fn count(&self) -> usize;
+    fn ordered_claims(&self) -> &[String];
+    fn claim_operands(&self) -> &[String];
+}
+
+pub(crate) trait VerifierStagePlanSource {
+    fn steps(&self) -> &[CpuProgramStepPlan];
+    fn transcript_squeezes(&self) -> &[CpuTranscriptSqueezePlan];
+    fn transcript_absorb_bytes(&self) -> Vec<VerifierTranscriptAbsorbBytesPlan>;
+    fn opening_inputs(&self) -> &[CpuOpeningInputPlan];
+    fn field_constants(&self) -> &[CpuFieldConstantPlan];
+    fn field_exprs(&self) -> &[CpuFieldExprPlan];
+    fn scalar_exprs(&self) -> &[CpuScalarExprPlan];
+    fn claims(&self) -> &[CpuSumcheckClaimPlan];
+    fn batches(&self) -> &[CpuSumcheckBatchPlan];
+    fn drivers(&self) -> &[CpuSumcheckDriverPlan];
+    fn instance_results(&self) -> &[CpuSumcheckInstanceResultPlan];
+    fn sumcheck_evals(&self) -> &[CpuSumcheckEvalPlan];
+    fn indexed_eval_families(&self) -> &[IndexedEvalFamilyPlan];
+    fn relation_output_values(&self) -> &[StructuredPolynomialEvalPlan];
+    fn relation_output_eval_families(&self) -> &[RelationOutputEvalFamilyPlan] {
+        &[]
+    }
+    fn relation_output_product_families(&self) -> &[RelationOutputProductFamilyPlan] {
+        &[]
+    }
+    fn relation_output_function_families(&self) -> &[RelationOutputFunctionFamilyPlan] {
+        &[]
+    }
+    fn relation_outputs(&self) -> &[RelationOutputPlan];
+    fn relation_local_inputs(
+        &self,
+        indexed_eval_families: &[IndexedEvalFamilyPlan],
+    ) -> Result<VerifierRelationLocalInputPlans, EmitError> {
+        let _ = indexed_eval_families;
+        Ok(VerifierRelationLocalInputPlans::default())
+    }
+    fn point_exprs(&self) -> Vec<VerifierPointExprPlan>;
+    fn opening_claims(&self) -> &[CpuOpeningClaimPlan];
+    fn opening_equalities(&self) -> &[CpuOpeningClaimEqualityPlan];
+    fn opening_batches(&self) -> &[CpuOpeningBatchPlan];
+}
+
+impl VerifierOpeningClaimSource for CpuOpeningClaimPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn oracle(&self) -> &str {
+        &self.oracle
+    }
+
+    fn domain(&self) -> &str {
+        &self.domain
+    }
+
+    fn point_arity(&self) -> usize {
+        self.point_arity
+    }
+
+    fn claim_kind(&self) -> &str {
+        &self.claim_kind
+    }
+
+    fn point_source(&self) -> &str {
+        &self.point_source
+    }
+
+    fn eval_source(&self) -> &str {
+        &self.eval_source
+    }
+}
+
+impl VerifierOpeningClaimEqualitySource for CpuOpeningClaimEqualityPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn mode(&self) -> &str {
+        &self.mode
+    }
+
+    fn lhs(&self) -> &str {
+        &self.lhs
+    }
+
+    fn rhs(&self) -> &str {
+        &self.rhs
+    }
+}
+
+impl VerifierOpeningBatchSource for CpuOpeningBatchPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn stage(&self) -> &str {
+        &self.stage
+    }
+
+    fn proof_slot(&self) -> &str {
+        &self.proof_slot
+    }
+
+    fn policy(&self) -> &str {
+        &self.policy
+    }
+
+    fn count(&self) -> usize {
+        self.count
+    }
+
+    fn ordered_claims(&self) -> &[String] {
+        &self.ordered_claims
+    }
+
+    fn claim_operands(&self) -> &[String] {
+        &self.claim_operands
+    }
+}
+
+impl VerifierProgramStepSource for CpuProgramStepPlan {
+    fn kind(&self) -> &str {
+        &self.kind
+    }
+
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+}
+
+impl VerifierTranscriptSqueezeSource for CpuTranscriptSqueezePlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn label(&self) -> &str {
+        &self.label
+    }
+
+    fn kind(&self) -> &str {
+        &self.kind
+    }
+
+    fn count(&self) -> usize {
+        self.count
+    }
+}
+
+impl VerifierTranscriptAbsorbBytesSource for CpuTranscriptAbsorbBytesPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn label(&self) -> &str {
+        &self.label
+    }
+
+    fn payload(&self) -> &str {
+        &self.payload
+    }
+}
+
+impl VerifierOpeningInputSource for CpuOpeningInputPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn source_stage(&self) -> &str {
+        &self.source_stage
+    }
+
+    fn source_claim(&self) -> &str {
+        &self.source_claim
+    }
+
+    fn oracle(&self) -> &str {
+        &self.oracle
+    }
+
+    fn domain(&self) -> &str {
+        &self.domain
+    }
+
+    fn point_arity(&self) -> usize {
+        self.point_arity
+    }
+
+    fn claim_kind(&self) -> &str {
+        &self.claim_kind
+    }
+}
+
+impl VerifierFieldConstantSource for CpuFieldConstantPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn field(&self) -> &str {
+        &self.field
+    }
+
+    fn value(&self) -> usize {
+        self.value
+    }
+}
+
+impl VerifierFieldExprSource for CpuFieldExprPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn formula(&self) -> &str {
+        &self.formula
+    }
+
+    fn operands(&self) -> &[String] {
+        &self.operands
+    }
+}
+
+impl VerifierScalarExprSource for CpuScalarExprPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn formula(&self) -> &str {
+        &self.formula
+    }
+
+    fn operands(&self) -> &[String] {
+        &self.operands
+    }
+}
+
+impl VerifierPointZeroSource for CpuPointZeroPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn field(&self) -> &str {
+        &self.field
+    }
+
+    fn arity(&self) -> usize {
+        self.arity
+    }
+}
+
+impl VerifierPointSliceSource for CpuPointSlicePlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn offset(&self) -> usize {
+        self.offset
+    }
+
+    fn length(&self) -> usize {
+        self.length
+    }
+
+    fn input(&self) -> &str {
+        &self.input
+    }
+}
+
+impl VerifierPointConcatSource for CpuPointConcatPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn layout(&self) -> &str {
+        &self.layout
+    }
+
+    fn arity(&self) -> usize {
+        self.arity
+    }
+
+    fn inputs(&self) -> &[String] {
+        &self.inputs
+    }
+}
+
+impl VerifierSumcheckClaimSource for CpuSumcheckClaimPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn stage(&self) -> &str {
+        &self.stage
+    }
+
+    fn domain(&self) -> &str {
+        &self.domain
+    }
+
+    fn num_rounds(&self) -> usize {
+        self.num_rounds
+    }
+
+    fn degree(&self) -> usize {
+        self.degree
+    }
+
+    fn claim(&self) -> &str {
+        &self.claim
+    }
+
+    fn relation(&self) -> Option<&str> {
+        self.relation.as_deref()
+    }
+
+    fn claim_value(&self) -> &str {
+        &self.claim_value
+    }
+}
+
+impl VerifierSumcheckBatchSource for CpuSumcheckBatchPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn stage(&self) -> &str {
+        &self.stage
+    }
+
+    fn proof_slot(&self) -> &str {
+        &self.proof_slot
+    }
+
+    fn policy(&self) -> &str {
+        &self.policy
+    }
+
+    fn count(&self) -> usize {
+        self.count
+    }
+
+    fn claim_operands(&self) -> &[String] {
+        &self.claim_operands
+    }
+
+    fn claim_label(&self) -> &str {
+        &self.claim_label
+    }
+
+    fn round_label(&self) -> &str {
+        &self.round_label
+    }
+
+    fn round_schedule(&self) -> &[usize] {
+        &self.round_schedule
+    }
+}
+
+impl VerifierSumcheckDriverSource for CpuSumcheckDriverPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn stage(&self) -> &str {
+        &self.stage
+    }
+
+    fn proof_slot(&self) -> &str {
+        &self.proof_slot
+    }
+
+    fn relation(&self) -> Option<&str> {
+        self.relation.as_deref()
+    }
+
+    fn batch(&self) -> &str {
+        &self.batch
+    }
+
+    fn policy(&self) -> &str {
+        &self.policy
+    }
+
+    fn round_schedule(&self) -> &[usize] {
+        &self.round_schedule
+    }
+
+    fn claim_label(&self) -> &str {
+        &self.claim_label
+    }
+
+    fn round_label(&self) -> &str {
+        &self.round_label
+    }
+
+    fn num_rounds(&self) -> usize {
+        self.num_rounds
+    }
+
+    fn degree(&self) -> usize {
+        self.degree
+    }
+}
+
+impl VerifierSumcheckInstanceResultSource for CpuSumcheckInstanceResultPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn source(&self) -> &str {
+        &self.source
+    }
+
+    fn claim(&self) -> &str {
+        &self.claim
+    }
+
+    fn relation(&self) -> &str {
+        &self.relation
+    }
+
+    fn index(&self) -> usize {
+        self.index
+    }
+
+    fn point_arity(&self) -> usize {
+        self.point_arity
+    }
+
+    fn num_rounds(&self) -> usize {
+        self.num_rounds
+    }
+
+    fn round_offset(&self) -> usize {
+        self.round_offset
+    }
+
+    fn point_order(&self) -> &str {
+        &self.point_order
+    }
+
+    fn degree(&self) -> usize {
+        self.degree
+    }
+}
+
+impl VerifierSumcheckEvalSource for CpuSumcheckEvalPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn source(&self) -> &str {
+        &self.source
+    }
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn index(&self) -> usize {
+        self.index
+    }
+
+    fn oracle(&self) -> &str {
+        &self.oracle
+    }
+}
+
+struct VerifierTranscriptPlanningOutput {
+    squeezes: Vec<VerifierTranscriptSqueezePlan>,
+    absorb_bytes: Vec<VerifierTranscriptAbsorbBytesPlan>,
+}
+
+struct VerifierSumcheckPlanningOutput {
+    claims: Vec<VerifierSumcheckClaimPlan>,
+    batches: Vec<VerifierSumcheckBatchPlan>,
+    drivers: Vec<VerifierSumcheckDriverPlan>,
+    instance_results: Vec<VerifierSumcheckInstanceResultPlan>,
+    evals: Vec<VerifierSumcheckEvalPlan>,
+}
+
+struct VerifierValueGraphPlanningOutput {
+    field_constants: Vec<VerifierFieldConstantPlan>,
+    field_exprs: Vec<VerifierFieldExprPlan>,
+    scalar_exprs: Vec<VerifierScalarExprPlan>,
+    indexed_eval_families: Vec<IndexedEvalFamilyPlan>,
+    relation_output_values: Vec<StructuredPolynomialEvalPlan>,
+    relation_output_eval_families: Vec<RelationOutputEvalFamilyPlan>,
+    relation_output_product_families: Vec<RelationOutputProductFamilyPlan>,
+    relation_output_function_families: Vec<RelationOutputFunctionFamilyPlan>,
+    relation_outputs: Vec<RelationOutputPlan>,
+    point_exprs: Vec<VerifierPointExprPlan>,
+}
+
+struct VerifierOpeningFlowPlanningOutput {
+    inputs: Vec<VerifierOpeningInputPlan>,
+    claims: Vec<VerifierOpeningClaimPlan>,
+    equalities: Vec<VerifierOpeningClaimEqualityPlan>,
+    batches: Vec<VerifierOpeningBatchPlan>,
+}
+
+pub(crate) fn plan_verifier_stage_from_cpu_sources<Source>(
+    source: &Source,
+) -> Result<VerifierStagePlan, EmitError>
+where
+    Source: VerifierStagePlanSource + ?Sized,
+{
+    let transcript = plan_transcript_flow(source)?;
+    let sumchecks = plan_verifier_sumchecks(source)?;
+    let value_graph = plan_field_and_relation_outputs(source)?;
+    let relation_local_inputs = source.relation_local_inputs(&value_graph.indexed_eval_families)?;
+    let opening_flow = plan_opening_flow(source)?;
+
+    Ok(VerifierStagePlan {
+        steps: resolve_cpu_program_steps(source)?,
+        transcript_squeezes: transcript.squeezes,
+        transcript_absorb_bytes: transcript.absorb_bytes,
+        opening_inputs: opening_flow.inputs,
+        field_constants: value_graph.field_constants,
+        field_exprs: value_graph.field_exprs,
+        scalar_exprs: value_graph.scalar_exprs,
+        claims: sumchecks.claims,
+        batches: sumchecks.batches,
+        drivers: sumchecks.drivers,
+        instance_results: sumchecks.instance_results,
+        sumcheck_evals: sumchecks.evals,
+        indexed_eval_families: value_graph.indexed_eval_families,
+        relation_output_values: value_graph.relation_output_values,
+        relation_output_eval_families: value_graph.relation_output_eval_families,
+        relation_output_product_families: value_graph.relation_output_product_families,
+        relation_output_function_families: value_graph.relation_output_function_families,
+        relation_outputs: value_graph.relation_outputs,
+        relation_local_inputs,
+        point_exprs: value_graph.point_exprs,
+        opening_claims: opening_flow.claims,
+        opening_equalities: opening_flow.equalities,
+        opening_batches: opening_flow.batches,
+    })
+}
+
+fn resolve_cpu_program_steps<Source>(
+    source: &Source,
+) -> Result<Vec<VerifierProgramStepPlan>, EmitError>
+where
+    Source: VerifierStagePlanSource + ?Sized,
+{
+    source
+        .steps()
+        .iter()
+        .map(|step| VerifierProgramStepPlan::from_cpu(step.kind(), step.symbol()))
+        .collect()
+}
+
+fn plan_transcript_flow<Source>(
+    source: &Source,
+) -> Result<VerifierTranscriptPlanningOutput, EmitError>
+where
+    Source: VerifierStagePlanSource + ?Sized,
+{
+    Ok(VerifierTranscriptPlanningOutput {
+        squeezes: source
+            .transcript_squeezes()
+            .iter()
+            .map(|squeeze| {
+                VerifierTranscriptSqueezePlan::from_cpu(
+                    squeeze.symbol(),
+                    squeeze.label(),
+                    squeeze.kind(),
+                    squeeze.count(),
+                )
+            })
+            .collect::<Result<Vec<_>, EmitError>>()?,
+        absorb_bytes: source.transcript_absorb_bytes(),
+    })
+}
+
+fn plan_verifier_sumchecks<Source>(
+    source: &Source,
+) -> Result<VerifierSumcheckPlanningOutput, EmitError>
+where
+    Source: VerifierStagePlanSource + ?Sized,
+{
+    Ok(VerifierSumcheckPlanningOutput {
+        claims: source
+            .claims()
+            .iter()
+            .map(|claim| {
+                Ok(VerifierSumcheckClaimPlan {
+                    symbol: claim.symbol().to_owned(),
+                    stage: claim.stage().to_owned(),
+                    domain: claim.domain().to_owned(),
+                    num_rounds: claim.num_rounds(),
+                    degree: claim.degree(),
+                    claim: claim.claim().to_owned(),
+                    relation: required_relation_from_cpu(
+                        claim.relation(),
+                        "claim",
+                        claim.symbol(),
+                    )?,
+                    claim_value: claim.claim_value().to_owned(),
+                })
+            })
+            .collect::<Result<Vec<_>, EmitError>>()?,
+        batches: source
+            .batches()
+            .iter()
+            .map(|batch| VerifierSumcheckBatchPlan {
+                symbol: batch.symbol().to_owned(),
+                stage: batch.stage().to_owned(),
+                proof_slot: batch.proof_slot().to_owned(),
+                policy: batch.policy().to_owned(),
+                count: batch.count(),
+                claim_operands: batch.claim_operands().to_vec(),
+                claim_label: batch.claim_label().to_owned(),
+                round_label: batch.round_label().to_owned(),
+                round_schedule: batch.round_schedule().to_vec(),
+            })
+            .collect(),
+        drivers: source
+            .drivers()
+            .iter()
+            .map(|driver| {
+                Ok(VerifierSumcheckDriverPlan {
+                    symbol: driver.symbol().to_owned(),
+                    stage: driver.stage().to_owned(),
+                    proof_slot: driver.proof_slot().to_owned(),
+                    relation: required_relation_from_cpu(
+                        driver.relation(),
+                        "driver",
+                        driver.symbol(),
+                    )?,
+                    batch: driver.batch().to_owned(),
+                    policy: driver.policy().to_owned(),
+                    round_schedule: driver.round_schedule().to_vec(),
+                    claim_label: driver.claim_label().to_owned(),
+                    round_label: driver.round_label().to_owned(),
+                    num_rounds: driver.num_rounds(),
+                    degree: driver.degree(),
+                })
+            })
+            .collect::<Result<Vec<_>, EmitError>>()?,
+        instance_results: source
+            .instance_results()
+            .iter()
+            .map(|instance| {
+                Ok(VerifierSumcheckInstanceResultPlan {
+                    symbol: instance.symbol().to_owned(),
+                    source: instance.source().to_owned(),
+                    claim: instance.claim().to_owned(),
+                    relation: relation_from_cpu(instance.relation())?,
+                    index: instance.index(),
+                    point_arity: instance.point_arity(),
+                    num_rounds: instance.num_rounds(),
+                    round_offset: instance.round_offset(),
+                    point_order: sumcheck_point_order_from_cpu(instance.point_order())?,
+                    degree: instance.degree(),
+                })
+            })
+            .collect::<Result<Vec<_>, EmitError>>()?,
+        evals: source
+            .sumcheck_evals()
+            .iter()
+            .map(|eval| VerifierSumcheckEvalPlan {
+                symbol: eval.symbol().to_owned(),
+                source: eval.source().to_owned(),
+                name: eval.name().to_owned(),
+                index: eval.index(),
+                oracle: eval.oracle().to_owned(),
+            })
+            .collect(),
+    })
+}
+
+fn plan_field_and_relation_outputs<Source>(
+    source: &Source,
+) -> Result<VerifierValueGraphPlanningOutput, EmitError>
+where
+    Source: VerifierStagePlanSource + ?Sized,
+{
+    Ok(VerifierValueGraphPlanningOutput {
+        field_constants: source
+            .field_constants()
+            .iter()
+            .map(|constant| VerifierFieldConstantPlan {
+                symbol: constant.symbol().to_owned(),
+                field: constant.field().to_owned(),
+                value: constant.value(),
+            })
+            .collect(),
+        field_exprs: source
+            .field_exprs()
+            .iter()
+            .map(|expr| {
+                VerifierFieldExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands())
+            })
+            .collect::<Result<Vec<_>, EmitError>>()?,
+        scalar_exprs: source
+            .scalar_exprs()
+            .iter()
+            .map(|expr| {
+                VerifierScalarExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands())
+            })
+            .collect::<Result<Vec<_>, EmitError>>()?,
+        indexed_eval_families: source.indexed_eval_families().to_vec(),
+        relation_output_values: source.relation_output_values().to_vec(),
+        relation_output_eval_families: source.relation_output_eval_families().to_vec(),
+        relation_output_product_families: source.relation_output_product_families().to_vec(),
+        relation_output_function_families: source.relation_output_function_families().to_vec(),
+        relation_outputs: source.relation_outputs().to_vec(),
+        point_exprs: source.point_exprs(),
+    })
+}
+
+fn plan_opening_flow<Source>(
+    source: &Source,
+) -> Result<VerifierOpeningFlowPlanningOutput, EmitError>
+where
+    Source: VerifierStagePlanSource + ?Sized,
+{
+    Ok(VerifierOpeningFlowPlanningOutput {
+        inputs: source
+            .opening_inputs()
+            .iter()
+            .map(|opening_input| {
+                VerifierOpeningInputPlan::from_cpu(
+                    opening_input.symbol(),
+                    opening_input.source_stage(),
+                    opening_input.source_claim(),
+                    opening_input.oracle(),
+                    opening_input.domain(),
+                    opening_input.point_arity(),
+                    opening_input.claim_kind(),
+                )
+            })
+            .collect::<Result<Vec<_>, EmitError>>()?,
+        claims: source
+            .opening_claims()
+            .iter()
+            .map(|claim| {
+                Ok(VerifierOpeningClaimPlan {
+                    symbol: claim.symbol().to_owned(),
+                    oracle: claim.oracle().to_owned(),
+                    domain: claim.domain().to_owned(),
+                    point_arity: claim.point_arity(),
+                    claim_kind: claim_kind_from_cpu(claim.claim_kind())?,
+                    point_source: claim.point_source().to_owned(),
+                    eval_source: claim.eval_source().to_owned(),
+                })
+            })
+            .collect::<Result<Vec<_>, EmitError>>()?,
+        equalities: source
+            .opening_equalities()
+            .iter()
+            .map(|equality| {
+                Ok(VerifierOpeningClaimEqualityPlan {
+                    symbol: equality.symbol().to_owned(),
+                    mode: opening_equality_mode_from_cpu(equality.mode())?,
+                    lhs: equality.lhs().to_owned(),
+                    rhs: equality.rhs().to_owned(),
+                })
+            })
+            .collect::<Result<Vec<_>, EmitError>>()?,
+        batches: source
+            .opening_batches()
+            .iter()
+            .map(|batch| VerifierOpeningBatchPlan {
+                symbol: batch.symbol().to_owned(),
+                stage: batch.stage().to_owned(),
+                proof_slot: batch.proof_slot().to_owned(),
+                policy: batch.policy().to_owned(),
+                count: batch.count(),
+                ordered_claims: batch.ordered_claims().to_vec(),
+                claim_operands: batch.claim_operands().to_vec(),
+            })
+            .collect(),
+    })
+}
+
+pub(crate) fn transcript_absorb_bytes_from_cpu<T: VerifierTranscriptAbsorbBytesSource>(
+    absorbs: &[T],
+) -> Vec<VerifierTranscriptAbsorbBytesPlan> {
+    absorbs
+        .iter()
+        .map(|absorb| {
+            VerifierTranscriptAbsorbBytesPlan::from_cpu(
+                absorb.symbol(),
+                absorb.label(),
+                absorb.payload(),
+            )
+        })
+        .collect()
+}
+
+pub(crate) fn point_zero_exprs_from_cpu<T: VerifierPointZeroSource>(
+    zeros: &[T],
+) -> Vec<VerifierPointExprPlan> {
+    zeros
+        .iter()
+        .map(|zero| VerifierPointExprPlan {
+            symbol: zero.symbol().to_owned(),
+            kind: VerifierPointExprKind::Zero {
+                field: zero.field().to_owned(),
+                arity: zero.arity(),
+            },
+            operands: Vec::new(),
+        })
+        .collect()
+}
+
+pub(crate) fn point_slice_exprs_from_cpu<T: VerifierPointSliceSource>(
+    slices: &[T],
+) -> Vec<VerifierPointExprPlan> {
+    slices
+        .iter()
+        .map(|slice| VerifierPointExprPlan {
+            symbol: slice.symbol().to_owned(),
+            kind: VerifierPointExprKind::Slice {
+                offset: slice.offset(),
+                length: slice.length(),
+            },
+            operands: vec![slice.input().to_owned()],
+        })
+        .collect()
+}
+
+pub(crate) fn point_concat_exprs_from_cpu<T: VerifierPointConcatSource>(
+    concats: &[T],
+) -> Vec<VerifierPointExprPlan> {
+    concats
+        .iter()
+        .map(|concat| VerifierPointExprPlan {
+            symbol: concat.symbol().to_owned(),
+            kind: VerifierPointExprKind::Concat {
+                layout: concat.layout().to_owned(),
+                arity: concat.arity(),
+            },
+            operands: concat.inputs().to_vec(),
+        })
+        .collect()
+}
+
+pub(crate) fn point_exprs_from_cpu<S, C>(slices: &[S], concats: &[C]) -> Vec<VerifierPointExprPlan>
+where
+    S: VerifierPointSliceSource,
+    C: VerifierPointConcatSource,
+{
+    let mut exprs = point_slice_exprs_from_cpu(slices);
+    exprs.extend(point_concat_exprs_from_cpu(concats));
+    exprs
+}
+
+pub(crate) fn point_exprs_with_zeros_from_cpu<Z, S, C>(
+    zeros: &[Z],
+    slices: &[S],
+    concats: &[C],
+) -> Vec<VerifierPointExprPlan>
+where
+    Z: VerifierPointZeroSource,
+    S: VerifierPointSliceSource,
+    C: VerifierPointConcatSource,
+{
+    let mut exprs = point_zero_exprs_from_cpu(zeros);
+    exprs.extend(point_exprs_from_cpu(slices, concats));
+    exprs
+}
+
+macro_rules! impl_verifier_plan_source_traits {
+    (
+        program = $program:ty,
+        $(absorb = $absorb:ident,)?
+        $(point_zero = $point_zero:ty,)?
+        $(indexed_eval_families = $indexed_eval_families:ident,)?
+        $(relation_output_eval_families = $relation_output_eval_families:ident,)?
+        $(relation_output_product_families = $relation_output_product_families:ident,)?
+        $(relation_output_function_families = $relation_output_function_families:ident,)?
+        $(relation_local_inputs = $relation_local_inputs:ident,)?
+        $(,)?
+    ) => {
+        impl $crate::protocols::jolt::verifier_plan::VerifierStagePlanSource for $program {
+            fn steps(&self) -> &[$crate::protocols::jolt::verifier_program_rows::CpuProgramStepPlan] { &self.steps }
+            fn transcript_squeezes(&self) -> &[$crate::protocols::jolt::verifier_program_rows::CpuTranscriptSqueezePlan] { &self.transcript_squeezes }
+            fn transcript_absorb_bytes(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierTranscriptAbsorbBytesPlan> {
+                $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!(
+                    @transcript_absorb_bytes self $(, $absorb)?
+                )
+            }
+            fn opening_inputs(&self) -> &[$crate::protocols::jolt::verifier_program_rows::CpuOpeningInputPlan] { &self.opening_inputs }
+            fn field_constants(&self) -> &[$crate::protocols::jolt::verifier_value_rows::CpuFieldConstantPlan] { &self.field_constants }
+            fn field_exprs(&self) -> &[$crate::protocols::jolt::verifier_value_rows::CpuFieldExprPlan] { &self.field_exprs }
+            fn scalar_exprs(&self) -> &[$crate::protocols::jolt::verifier_value_rows::CpuScalarExprPlan] { &self.scalar_exprs }
+            fn claims(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckClaimPlan] { &self.claims }
+            fn batches(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckBatchPlan] { &self.batches }
+            fn drivers(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckDriverPlan] { &self.drivers }
+            fn instance_results(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan] { &self.instance_results }
+            fn sumcheck_evals(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckEvalPlan] { &self.evals }
+            fn indexed_eval_families(&self) -> &[$crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan] {
+                $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!(
+                    @indexed_eval_families self $(, $indexed_eval_families)?
+                )
+            }
+            fn relation_output_values(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::StructuredPolynomialEvalPlan] {
+                &self.relation_output_values
+            }
+            fn relation_output_eval_families(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputEvalFamilyPlan] {
+                $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!(
+                    @relation_output_eval_families self $(, $relation_output_eval_families)?
+                )
+            }
+            fn relation_output_product_families(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputProductFamilyPlan] {
+                $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!(
+                    @relation_output_product_families self $(, $relation_output_product_families)?
+                )
+            }
+            fn relation_output_function_families(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputFunctionFamilyPlan] {
+                $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!(
+                    @relation_output_function_families self $(, $relation_output_function_families)?
+                )
+            }
+            fn relation_outputs(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputPlan] {
+                &self.relation_outputs
+            }
+            fn relation_local_inputs(
+                &self,
+                indexed_eval_families: &[$crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan],
+            ) -> Result<
+                $crate::protocols::jolt::verifier_plan::VerifierRelationLocalInputPlans,
+                $crate::emit::rust::EmitError,
+            > {
+                $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!(
+                    @relation_local_inputs indexed_eval_families $(, $relation_local_inputs)?
+                )
+            }
+            fn point_exprs(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierPointExprPlan> {
+                $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!(
+                    @point_exprs self $(, $point_zero)?
+                )
+            }
+            fn opening_claims(&self) -> &[$crate::protocols::jolt::verifier_opening_rows::CpuOpeningClaimPlan] { &self.opening_claims }
+            fn opening_equalities(&self) -> &[$crate::protocols::jolt::verifier_opening_rows::CpuOpeningClaimEqualityPlan] { &self.opening_equalities }
+            fn opening_batches(&self) -> &[$crate::protocols::jolt::verifier_opening_rows::CpuOpeningBatchPlan] { &self.opening_batches }
+        }
+
+    };
+    (@transcript_absorb_bytes $self:ident, $absorb:ident) => {
+        $crate::protocols::jolt::verifier_plan::transcript_absorb_bytes_from_cpu(
+            &$self.transcript_absorb_bytes,
+        )
+    };
+    (@transcript_absorb_bytes $self:ident) => {
+        Vec::new()
+    };
+    (@point_exprs $self:ident, $point_zero:ty) => {
+        $crate::protocols::jolt::verifier_plan::point_exprs_with_zeros_from_cpu(
+            &$self.point_zeros,
+            &$self.point_slices,
+            &$self.point_concats,
+        )
+    };
+    (@point_exprs $self:ident) => {
+        $crate::protocols::jolt::verifier_plan::point_exprs_from_cpu(
+            &$self.point_slices,
+            &$self.point_concats,
+        )
+    };
+    (@indexed_eval_families $self:ident, $indexed_eval_families:ident) => {
+        &$self.$indexed_eval_families
+    };
+    (@indexed_eval_families $self:ident) => {
+        &[]
+    };
+    (@relation_output_eval_families $self:ident, $relation_output_eval_families:ident) => {
+        &$self.$relation_output_eval_families
+    };
+    (@relation_output_eval_families $self:ident) => {
+        &[]
+    };
+    (@relation_output_product_families $self:ident, $relation_output_product_families:ident) => {
+        &$self.$relation_output_product_families
+    };
+    (@relation_output_product_families $self:ident) => {
+        &[]
+    };
+    (@relation_output_function_families $self:ident, $relation_output_function_families:ident) => {
+        &$self.$relation_output_function_families
+    };
+    (@relation_output_function_families $self:ident) => {
+        &[]
+    };
+    (@relation_local_inputs $indexed_eval_families:ident, stage5_instruction_read_raf) => {{
+        let mut plans =
+            $crate::protocols::jolt::verifier_plan::VerifierRelationLocalInputPlans::default();
+        plans.add_stage5_instruction_read_raf(
+            $crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan::from_eval_families(
+                $indexed_eval_families,
+            )?,
+        )?;
+        Ok(plans)
+    }};
+    (@relation_local_inputs $indexed_eval_families:ident, stage6_bytecode_read_raf) => {{
+        let mut plans =
+            $crate::protocols::jolt::verifier_plan::VerifierRelationLocalInputPlans::default();
+        plans.add_stage6_bytecode_read_raf(
+            $crate::protocols::jolt::stage6_bytecode_read_raf_plan::Stage6BytecodeReadRafEmitPlan::from_eval_families(
+                $indexed_eval_families,
+            )?,
+        )?;
+        Ok(plans)
+    }};
+    (@relation_local_inputs $indexed_eval_families:ident) => {{
+        let _ = $indexed_eval_families;
+        Ok($crate::protocols::jolt::verifier_plan::VerifierRelationLocalInputPlans::default())
+    }};
+}
+
+pub(crate) use impl_verifier_plan_source_traits;
+
+pub(crate) fn relation_from_cpu(value: &str) -> Result<JoltVerifierRelationKind, EmitError> {
+    JoltVerifierRelationKind::from_cpu_attr(value).map_err(plan_error)
+}
+
+pub(crate) fn required_relation_from_cpu(
+    value: Option<&str>,
+    kind: &str,
+    symbol: &str,
+) -> Result<JoltVerifierRelationKind, EmitError> {
+    value
+        .ok_or_else(|| EmitError::new(format!("missing verifier {kind} relation for `{symbol}`")))
+        .and_then(relation_from_cpu)
+}
+
+pub(crate) fn claim_kind_from_cpu(value: &str) -> Result<ClaimKind, EmitError> {
+    ClaimKind::from_cpu_attr(value).map_err(plan_error)
+}
+
+pub(crate) fn sumcheck_point_order_from_cpu(value: &str) -> Result<SumcheckPointOrder, EmitError> {
+    SumcheckPointOrder::from_cpu_attr(value).map_err(plan_error)
+}
+
+pub(crate) fn opening_equality_mode_from_cpu(
+    value: &str,
+) -> Result<OpeningEqualityMode, EmitError> {
+    OpeningEqualityMode::from_cpu_attr(value).map_err(plan_error)
+}
+
+pub(crate) fn relation_kind_expr(
+    stage_type_prefix: &str,
+    relation: JoltVerifierRelationKind,
+) -> String {
+    format!(
+        "{stage_type_prefix}RelationKind::{}",
+        relation.rust_variant()
+    )
+}
+
+pub(crate) fn program_step_kind_expr(stage_type_prefix: &str, kind: ProgramStepKind) -> String {
+    format!(
+        "{stage_type_prefix}ProgramStepKind::{}",
+        kind.rust_variant()
+    )
+}
+
+pub(crate) fn transcript_squeeze_kind_expr(
+    stage_type_prefix: &str,
+    kind: TranscriptSqueezeKind,
+) -> String {
+    format!(
+        "{stage_type_prefix}TranscriptSqueezeKind::{}",
+        kind.rust_variant()
+    )
+}
+
+pub(crate) fn claim_kind_expr(stage_type_prefix: &str, kind: ClaimKind) -> String {
+    format!("{stage_type_prefix}ClaimKind::{}", kind.rust_variant())
+}
+
+pub(crate) fn field_expr_kind_expr(stage_type_prefix: &str, kind: &FieldExprKind) -> String {
+    format!(
+        "{stage_type_prefix}FieldExprKind::{}",
+        kind.rust_variant_expr()
+    )
+}
+
+pub(crate) fn scalar_expr_kind_expr(stage_type_prefix: &str, kind: &ScalarExprKind) -> String {
+    format!(
+        "{stage_type_prefix}ScalarExprKind::{}",
+        kind.rust_variant_expr()
+    )
+}
+
+pub(crate) fn sumcheck_point_order_expr(point_order: SumcheckPointOrder) -> String {
+    format!(
+        "bolt_verifier_runtime::SumcheckPointOrder::{}",
+        point_order.rust_variant()
+    )
+}
+
+pub(crate) fn opening_equality_mode_expr(
+    stage_type_prefix: &str,
+    mode: OpeningEqualityMode,
+) -> String {
+    format!(
+        "{stage_type_prefix}OpeningEqualityMode::{}",
+        mode.rust_variant()
+    )
+}
+
+pub(crate) fn emit_program_step_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    steps: &[VerifierProgramStepPlan],
+) -> String {
+    let steps = steps
+        .iter()
+        .map(|step| {
+            format!(
+                "    {stage_type_prefix}ProgramStepPlan {{ kind: {}, symbol: {} }},",
+                program_step_kind_expr(stage_type_prefix, step.kind),
+                rust_str(&step.symbol),
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_PROGRAM_STEPS: &[{stage_type_prefix}ProgramStepPlan] = &[\n{steps}\n];\n\n"
+    )
+}
+
+pub(crate) fn emit_transcript_squeeze_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    squeezes: &[VerifierTranscriptSqueezePlan],
+) -> String {
+    let squeezes = squeezes
+        .iter()
+        .map(|squeeze| {
+            format!(
+                "    {stage_type_prefix}TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},",
+                rust_str(&squeeze.symbol),
+                rust_str(&squeeze.label),
+                transcript_squeeze_kind_expr(stage_type_prefix, squeeze.kind),
+                squeeze.count,
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_TRANSCRIPT_SQUEEZES: &[{stage_type_prefix}TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n"
+    )
+}
+
+pub(crate) fn emit_transcript_absorb_bytes_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    absorbs: &[VerifierTranscriptAbsorbBytesPlan],
+) -> String {
+    let absorbs = absorbs
+        .iter()
+        .map(|absorb| {
+            format!(
+                "    {stage_type_prefix}TranscriptAbsorbBytesPlan {{ symbol: {}, label: {}, payload: {} }},",
+                rust_str(&absorb.symbol),
+                rust_str(&absorb.label),
+                rust_str(&absorb.payload),
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_TRANSCRIPT_ABSORB_BYTES: &[{stage_type_prefix}TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n"
+    )
+}
+
+pub(crate) fn emit_opening_input_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    inputs: &[VerifierOpeningInputPlan],
+) -> String {
+    let inputs = inputs
+        .iter()
+        .map(|input| {
+            format!(
+                "    {stage_type_prefix}OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},",
+                rust_str(&input.symbol),
+                rust_str(&input.source_stage),
+                rust_str(&input.source_claim),
+                rust_str(&input.oracle),
+                rust_str(&input.domain),
+                input.point_arity,
+                claim_kind_expr(stage_type_prefix, input.claim_kind),
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_OPENING_INPUTS: &[{stage_type_prefix}OpeningInputPlan] = &[\n{inputs}\n];\n\n"
+    )
+}
+
+pub(crate) fn emit_field_expr_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    exprs: &[VerifierFieldExprPlan],
+) -> String {
+    let exprs = exprs
+        .iter()
+        .map(|expr| {
+            format!(
+                "    {stage_type_prefix}FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},",
+                rust_str(&expr.symbol),
+                field_expr_kind_expr(stage_type_prefix, &expr.kind),
+                field_expr_operand_slice_expr(&expr.operands),
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_FIELD_EXPRS: &[{stage_type_prefix}FieldExprPlan] = &[\n{exprs}\n];\n"
+    )
+}
+
+pub(crate) fn emit_scalar_expr_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    exprs: &[VerifierScalarExprPlan],
+) -> String {
+    let exprs = exprs
+        .iter()
+        .map(|expr| {
+            format!(
+                "    {stage_type_prefix}ScalarExprPlan {{ symbol: {}, kind: {}, operands: {} }},",
+                rust_str(&expr.symbol),
+                scalar_expr_kind_expr(stage_type_prefix, &expr.kind),
+                scalar_expr_operand_slice_expr(&expr.operands),
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_SCALAR_EXPRS: &[{stage_type_prefix}ScalarExprPlan] = &[\n{exprs}\n];\n"
+    )
+}
+
+pub(crate) fn emit_field_expr_constants_chunked(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    helper_name: &str,
+    exprs: &[VerifierFieldExprPlan],
+    chunk_size: usize,
+) -> String {
+    let rows = exprs
+        .chunks(chunk_size)
+        .map(|chunk| {
+            let exprs = chunk
+                .iter()
+                .map(|expr| {
+                    format!(
+                        "{helper_name}({}, {}, {})",
+                        rust_str(&expr.symbol),
+                        field_expr_kind_expr(stage_type_prefix, &expr.kind),
+                        field_expr_operand_slice_expr(&expr.operands)
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join(", ");
+            format!("    {exprs},")
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "const fn {helper_name}(symbol: &'static str, kind: {stage_type_prefix}FieldExprKind, operands: &'static [&'static str]) -> {stage_type_prefix}FieldExprPlan {{\n    {stage_type_prefix}FieldExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const {const_prefix}_FIELD_EXPRS: &[{stage_type_prefix}FieldExprPlan] = &[\n{rows}\n];\n"
+    )
+}
+
+fn field_expr_operand_slice_expr(operands: &[VerifierScalarValueRef]) -> String {
+    if operands.is_empty() {
+        return "&[]".to_owned();
+    }
+    let values = operands
+        .iter()
+        .map(|operand| rust_str(operand.symbol()))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("&[{values}]")
+}
+
+pub(crate) fn emit_scalar_expr_constants_chunked(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    helper_name: &str,
+    exprs: &[VerifierScalarExprPlan],
+    chunk_size: usize,
+) -> String {
+    let rows = exprs
+        .chunks(chunk_size)
+        .map(|chunk| {
+            let exprs = chunk
+                .iter()
+                .map(|expr| {
+                    format!(
+                        "{helper_name}({}, {}, {})",
+                        rust_str(&expr.symbol),
+                        scalar_expr_kind_expr(stage_type_prefix, &expr.kind),
+                        scalar_expr_operand_slice_expr(&expr.operands)
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join(", ");
+            format!("    {exprs},")
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "const fn {helper_name}(symbol: &'static str, kind: {stage_type_prefix}ScalarExprKind, operands: &'static [&'static str]) -> {stage_type_prefix}ScalarExprPlan {{\n    {stage_type_prefix}ScalarExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const {const_prefix}_SCALAR_EXPRS: &[{stage_type_prefix}ScalarExprPlan] = &[\n{rows}\n];\n"
+    )
+}
+
+fn scalar_expr_operand_slice_expr(operands: &[VerifierScalarExprOperand]) -> String {
+    if operands.is_empty() {
+        return "&[]".to_owned();
+    }
+    let values = operands
+        .iter()
+        .map(|operand| rust_str(operand.symbol()))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("&[{values}]")
+}
+
+pub(crate) fn emit_sumcheck_claim_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    claims: &[VerifierSumcheckClaimPlan],
+) -> String {
+    let claims = claims
+        .iter()
+        .map(|claim| {
+            format!(
+                "    {stage_type_prefix}SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {} }},",
+                rust_str(&claim.symbol),
+                rust_str(&claim.stage),
+                rust_str(&claim.domain),
+                claim.num_rounds,
+                claim.degree,
+                rust_str(&claim.claim),
+                relation_kind_expr(stage_type_prefix, claim.relation),
+                rust_str(&claim.claim_value),
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_SUMCHECK_CLAIMS: &[{stage_type_prefix}SumcheckClaimPlan] = &[\n{claims}\n];\n"
+    )
+}
+
+pub(crate) fn emit_sumcheck_batch_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    batches: &[VerifierSumcheckBatchPlan],
+) -> String {
+    let mut source = String::new();
+    for (index, batch) in batches.iter().enumerate() {
+        emit_str_array_if_not_inline(
+            &mut source,
+            &format!("{const_prefix}_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS"),
+            &batch.claim_operands,
+            4,
+        );
+        source.push_str(&emit_usize_array(
+            &format!("{const_prefix}_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"),
+            &batch.round_schedule,
+        ));
+    }
+    let batches = batches
+        .iter()
+        .enumerate()
+        .map(|(index, batch)| {
+            let claim_operands = str_slice_ref_expr(
+                &format!("{const_prefix}_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS"),
+                &batch.claim_operands,
+                4,
+            );
+            format!(
+                "    {stage_type_prefix}SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: {const_prefix}_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},",
+                rust_str(&batch.symbol),
+                rust_str(&batch.stage),
+                rust_str(&batch.proof_slot),
+                rust_str(&batch.policy),
+                batch.count,
+                claim_operands,
+                rust_str(&batch.claim_label),
+                rust_str(&batch.round_label)
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    let _ = write!(
+        source,
+        "pub const {const_prefix}_SUMCHECK_BATCHES: &[{stage_type_prefix}SumcheckBatchPlan] = &[\n{batches}\n];\n"
+    );
+    source
+}
+
+pub(crate) fn emit_sumcheck_driver_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    drivers: &[VerifierSumcheckDriverPlan],
+) -> String {
+    let mut source = String::new();
+    for (index, driver) in drivers.iter().enumerate() {
+        source.push_str(&emit_usize_array(
+            &format!("{const_prefix}_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE"),
+            &driver.round_schedule,
+        ));
+    }
+    let drivers = drivers
+        .iter()
+        .enumerate()
+        .map(|(index, driver)| {
+            format!(
+                "    {stage_type_prefix}SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: None, relation: Some({}), batch: {}, policy: {}, round_schedule: {const_prefix}_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},",
+                rust_str(&driver.symbol),
+                rust_str(&driver.stage),
+                rust_str(&driver.proof_slot),
+                relation_kind_expr(stage_type_prefix, driver.relation),
+                rust_str(&driver.batch),
+                rust_str(&driver.policy),
+                rust_str(&driver.claim_label),
+                rust_str(&driver.round_label),
+                driver.num_rounds,
+                driver.degree,
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    let _ = write!(
+        source,
+        "pub const {const_prefix}_SUMCHECK_DRIVERS: &[{stage_type_prefix}SumcheckDriverPlan] = &[\n{drivers}\n];\n"
+    );
+    source
+}
+
+pub(crate) fn emit_sumcheck_instance_result_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    instances: &[VerifierSumcheckInstanceResultPlan],
+) -> String {
+    let instances = instances
+        .iter()
+        .map(|instance| {
+            format!(
+                "    {stage_type_prefix}SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},",
+                rust_str(&instance.symbol),
+                rust_str(&instance.source),
+                rust_str(&instance.claim),
+                relation_kind_expr(stage_type_prefix, instance.relation),
+                instance.index,
+                instance.point_arity,
+                instance.num_rounds,
+                instance.round_offset,
+                sumcheck_point_order_expr(instance.point_order),
+                instance.degree,
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_SUMCHECK_INSTANCE_RESULTS: &[{stage_type_prefix}SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n"
+    )
+}
+
+pub(crate) fn point_expr_kind_expr(
+    stage_type_prefix: &str,
+    kind: &VerifierPointExprKind,
+) -> String {
+    match kind {
+        VerifierPointExprKind::Zero { field, arity } => format!(
+            "{stage_type_prefix}PointExprKind::Zero {{ field: {}, arity: {arity} }}",
+            rust_str(field)
+        ),
+        VerifierPointExprKind::Slice { offset, length } => {
+            format!(
+                "{stage_type_prefix}PointExprKind::Slice {{ offset: {offset}, length: {length} }}"
+            )
+        }
+        VerifierPointExprKind::Concat { layout, arity } => format!(
+            "{stage_type_prefix}PointExprKind::Concat {{ layout: {}, arity: {arity} }}",
+            rust_str(layout)
+        ),
+    }
+}
+
+pub(crate) fn emit_point_expr_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    exprs: &[VerifierPointExprPlan],
+) -> String {
+    let exprs = exprs
+        .iter()
+        .map(|expr| {
+            format!(
+                "    {stage_type_prefix}PointExprPlan {{ symbol: {}, kind: {}, operands: {} }},",
+                rust_str(&expr.symbol),
+                point_expr_kind_expr(stage_type_prefix, &expr.kind),
+                rust_str_slice_expr(&expr.operands)
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_POINT_EXPRS: &[{stage_type_prefix}PointExprPlan] = &[\n{exprs}\n];\n\n"
+    )
+}
+
+pub(crate) fn emit_opening_claim_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    claims: &[VerifierOpeningClaimPlan],
+) -> String {
+    let claims = claims
+        .iter()
+        .map(|claim| {
+            format!(
+                "    {stage_type_prefix}OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},",
+                rust_str(&claim.symbol),
+                rust_str(&claim.oracle),
+                rust_str(&claim.domain),
+                claim.point_arity,
+                claim_kind_expr(stage_type_prefix, claim.claim_kind),
+                rust_str(&claim.point_source),
+                rust_str(&claim.eval_source),
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_OPENING_CLAIMS: &[{stage_type_prefix}OpeningClaimPlan] = &[\n{claims}\n];\n\n"
+    )
+}
+
+pub(crate) fn emit_opening_claim_equality_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    equalities: &[VerifierOpeningClaimEqualityPlan],
+) -> String {
+    let equalities = equalities
+        .iter()
+        .map(|equality| {
+            format!(
+                "    {stage_type_prefix}OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},",
+                rust_str(&equality.symbol),
+                opening_equality_mode_expr(stage_type_prefix, equality.mode),
+                rust_str(&equality.lhs),
+                rust_str(&equality.rhs),
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_OPENING_EQUALITIES: &[{stage_type_prefix}OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n"
+    )
+}
+
+pub(crate) fn emit_opening_batch_constants(
+    stage_type_prefix: &str,
+    const_prefix: &str,
+    batches: &[VerifierOpeningBatchPlan],
+) -> String {
+    let batches = batches
+        .iter()
+        .map(|batch| {
+            format!(
+                "    {stage_type_prefix}OpeningBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {} }},",
+                rust_str(&batch.symbol),
+                rust_str(&batch.stage),
+                rust_str(&batch.proof_slot),
+                rust_str(&batch.policy),
+                batch.count,
+                rust_str_slice_expr(&batch.ordered_claims),
+                rust_str_slice_expr(&batch.claim_operands)
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "pub const {const_prefix}_OPENING_BATCHES: &[{stage_type_prefix}OpeningBatchPlan] = &[\n{batches}\n];\n"
+    )
+}
+
+fn emit_usize_array(name: &str, values: &[usize]) -> String {
+    let entries = values
+        .iter()
+        .map(usize::to_string)
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("pub const {name}: &[usize] = &[{entries}];\n\n")
+}
+
+fn rust_str_slice_expr(values: &[String]) -> String {
+    if values.is_empty() {
+        return "&[]".to_owned();
+    }
+    let values = values
+        .iter()
+        .map(|value| rust_str(value))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("&[{values}]")
+}
+
+fn str_slice_ref_expr(name: &str, values: &[String], inline_limit: usize) -> String {
+    if values.len() <= inline_limit {
+        return rust_str_slice_expr(values);
+    }
+    name.to_owned()
+}
+
+fn emit_str_array_if_not_inline(
+    source: &mut String,
+    name: &str,
+    values: &[String],
+    inline_limit: usize,
+) {
+    if values.len() <= inline_limit {
+        return;
+    }
+    let entries = values
+        .iter()
+        .map(|value| rust_str(value))
+        .collect::<Vec<_>>()
+        .join(",\n    ");
+    let _ = write!(
+        source,
+        "pub const {name}: &[&str] = &[\n    {entries},\n];\n\n"
+    );
+}
+
+fn rust_str(value: &str) -> String {
+    format!("{value:?}")
+}
+
+fn verify_plan_operand_count(
+    kind: &str,
+    symbol: &str,
+    expected: usize,
+    actual: usize,
+) -> Result<(), EmitError> {
+    verify_plan_count(kind, symbol, expected, actual).map_err(|_| {
+        EmitError::new(format!(
+            "{kind} @{symbol} operand count mismatch: expected {expected}, got {actual}"
+        ))
+    })
+}
+
+fn verify_plan_count(
+    kind: &str,
+    symbol: &str,
+    expected: usize,
+    actual: usize,
+) -> Result<(), EmitError> {
+    if expected == actual {
+        Ok(())
+    } else {
+        Err(EmitError::new(format!(
+            "{kind} @{symbol} count mismatch: expected {expected}, got {actual}"
+        )))
+    }
+}
+
+fn plan_error(error: RustTargetPlanError) -> EmitError {
+    EmitError::new(error.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan;
+    use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan;
+    use crate::protocols::jolt::verifier_local_scalars::{
+        JoltLocalScalarEmitPlan, JoltLocalScalarMleKind,
+    };
+    use crate::protocols::jolt::verifier_relation_outputs::{
+        StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength,
+        StructuredPolynomialPointOrder, StructuredPolynomialPointPlan,
+        StructuredPolynomialPointSegment,
+    };
+    use crate::protocols::jolt::verifier_values::{
+        VerifierFieldVectorValueRef, VerifierPointValueRef, VerifierScalarValueKind,
+        VerifierScalarValuePlan,
+    };
+
+    use super::{
+        VerifierFieldExprPlan, VerifierPointExprKind, VerifierPointExprPlan,
+        VerifierScalarExprOperand, VerifierScalarExprPlan, VerifierStagePlan,
+    };
+
+    #[test]
+    fn scalar_value_plans_classify_structured_evals_and_local_scalars() -> Result<(), String> {
+        let mut plan = VerifierStagePlan::default();
+        plan.relation_output_values
+            .push(structured_polynomial_eval("stage5.output.eq"));
+        plan.scalar_exprs.push(
+            VerifierScalarExprPlan::from_cpu(
+                "stage5.output.eq",
+                "poly.structured_eval:eq:full:full:as_is:full:full:as_is",
+                &["point.x".to_owned(), "point.y".to_owned()],
+            )
+            .map_err(|error| error.to_string())?,
+        );
+        plan.scalar_exprs.push(
+            VerifierScalarExprPlan::from_cpu(
+                "stage5.output.sum",
+                "field_vector.sum",
+                &["field.vector".to_owned()],
+            )
+            .map_err(|error| error.to_string())?,
+        );
+        plan.relation_local_inputs
+            .add_stage5_instruction_read_raf(stage5_local_input_plan())
+            .map_err(|error| error.to_string())?;
+
+        let values = plan.scalar_value_plans();
+
+        assert_eq!(
+            values
+                .iter()
+                .filter(|value| value.symbol == "stage5.output.eq")
+                .count(),
+            1
+        );
+        assert!(values.contains(&VerifierScalarValuePlan::new(
+            "stage5.output.eq",
+            VerifierScalarValueKind::StructuredPolynomialEval
+        )));
+        assert!(values.contains(&VerifierScalarValuePlan::new(
+            "stage5.output.sum",
+            VerifierScalarValueKind::ScalarExpr
+        )));
+        assert!(values.contains(&VerifierScalarValuePlan::new(
+            "stage5.local.lookup",
+            VerifierScalarValueKind::RelationOutputLocal
+        )));
+        Ok(())
+    }
+
+    #[test]
+    fn field_expr_plan_types_scalar_operands() -> Result<(), String> {
+        let expr = VerifierFieldExprPlan::from_cpu(
+            "field.expr",
+            "field.add",
+            &["left.value".to_owned(), "right.value".to_owned()],
+        )
+        .map_err(|error| error.to_string())?;
+
+        assert_eq!(expr.operands[0].symbol(), "left.value");
+        assert_eq!(expr.operands[1].symbol(), "right.value");
+        Ok(())
+    }
+
+    #[test]
+    fn scalar_expr_plan_types_operands_by_formula() -> Result<(), String> {
+        let field_expr = VerifierScalarExprPlan::from_cpu(
+            "field.expr",
+            "field.power_strided_weighted_sum:2:1:0:1:2",
+            &["field.value".to_owned()],
+        )
+        .map_err(|error| error.to_string())?;
+        assert!(matches!(
+            &field_expr.operands[..],
+            [VerifierScalarExprOperand::Field(value_ref)] if value_ref.symbol() == "field.value"
+        ));
+
+        let vector_expr = VerifierScalarExprPlan::from_cpu(
+            "vector.expr",
+            "field_vector.product",
+            &["vector.value".to_owned()],
+        )
+        .map_err(|error| error.to_string())?;
+        assert!(matches!(
+            &vector_expr.operands[..],
+            [VerifierScalarExprOperand::FieldVector(value_ref)] if value_ref.symbol() == "vector.value"
+        ));
+
+        let point_expr = VerifierScalarExprPlan::from_cpu(
+            "point.expr",
+            "point.element:0",
+            &["point.value".to_owned()],
+        )
+        .map_err(|error| error.to_string())?;
+        assert!(matches!(
+            &point_expr.operands[..],
+            [VerifierScalarExprOperand::Point(value_ref)] if value_ref.symbol() == "point.value"
+        ));
+
+        Ok(())
+    }
+
+    #[test]
+    fn field_vector_values_classify_indexed_eval_families() {
+        let mut plan = VerifierStagePlan::default();
+        plan.indexed_eval_families.push(IndexedEvalFamilyPlan {
+            symbol: "stage5.indexed.evals".to_owned(),
+            evals: vec!["stage5.eval.0".to_owned()],
+        });
+
+        let values = plan.field_vector_values();
+
+        assert!(values.contains_ref(&VerifierFieldVectorValueRef::new("stage5.indexed.evals")));
+        assert!(!values.contains_ref(&VerifierFieldVectorValueRef::new("missing.family")));
+    }
+
+    #[test]
+    fn point_values_classify_point_exprs() {
+        let mut plan = VerifierStagePlan::default();
+        plan.point_exprs.push(VerifierPointExprPlan {
+            symbol: "point.value".to_owned(),
+            kind: VerifierPointExprKind::Zero {
+                field: "bn254_fr".to_owned(),
+                arity: 2,
+            },
+            operands: Vec::new(),
+        });
+
+        let values = plan.point_values();
+
+        assert!(values.contains_ref(&VerifierPointValueRef::new("point.value")));
+        assert!(!values.contains_ref(&VerifierPointValueRef::new("missing.point")));
+    }
+
+    fn structured_polynomial_eval(symbol: &str) -> StructuredPolynomialEvalPlan {
+        StructuredPolynomialEvalPlan {
+            symbol: symbol.to_owned(),
+            polynomial: StructuredPolynomialKind::Eq,
+            x_point: structured_polynomial_point("point.x"),
+            y_point: structured_polynomial_point("point.y"),
+        }
+    }
+
+    fn structured_polynomial_point(source: &str) -> StructuredPolynomialPointPlan {
+        StructuredPolynomialPointPlan {
+            source: VerifierPointValueRef::new(source),
+            segment: StructuredPolynomialPointSegment::Full,
+            length: StructuredPolynomialPointLength::Full,
+            order: StructuredPolynomialPointOrder::AsIs,
+        }
+    }
+
+    fn stage5_local_input_plan() -> Stage5InstructionReadRafEmitPlan {
+        Stage5InstructionReadRafEmitPlan {
+            point: "stage5.point".to_owned(),
+            lookup_output_point: "stage2.lookup_output".to_owned(),
+            table_flag_evals: IndexedEvalFamilyPlan {
+                symbol: "table.flags".to_owned(),
+                evals: Vec::new(),
+            },
+            table_flag_evals_ref: "&TABLE_FLAGS".to_owned(),
+            instruction_ra_evals: IndexedEvalFamilyPlan {
+                symbol: "instruction.ra".to_owned(),
+                evals: Vec::new(),
+            },
+            instruction_ra_evals_ref: "&INSTRUCTION_RA".to_owned(),
+            raf_flag_eval: "raf.flag".to_owned(),
+            gamma: "gamma".to_owned(),
+            local_scalars: vec![JoltLocalScalarEmitPlan {
+                symbol: "stage5.local.lookup".to_owned(),
+                kind: JoltLocalScalarMleKind::LookupTable { index: 0 },
+            }],
+            log_k: 128,
+        }
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_point_rows.rs b/crates/bolt/src/protocols/jolt/verifier_point_rows.rs
new file mode 100644
index 0000000000..b53de28d64
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_point_rows.rs
@@ -0,0 +1,63 @@
+use melior::ir::OperationRef;
+
+use crate::emit::rust::EmitError;
+use crate::protocols::jolt::cpu_attrs::{
+    int_attr, operand_symbol, operand_symbols, string_attr, symbol_attr,
+};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuPointZeroPlan {
+    pub symbol: String,
+    pub field: String,
+    pub arity: usize,
+}
+
+impl CpuPointZeroPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            field: symbol_attr(operation, "field")?,
+            arity: int_attr(operation, "arity")?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuPointSlicePlan {
+    pub symbol: String,
+    pub source: String,
+    pub offset: usize,
+    pub length: usize,
+    pub input: String,
+}
+
+impl CpuPointSlicePlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            source: symbol_attr(operation, "source")?,
+            offset: int_attr(operation, "offset")?,
+            length: int_attr(operation, "length")?,
+            input: operand_symbol(operation, 0)?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuPointConcatPlan {
+    pub symbol: String,
+    pub layout: String,
+    pub arity: usize,
+    pub inputs: Vec<String>,
+}
+
+impl CpuPointConcatPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            layout: string_attr(operation, "layout")?,
+            arity: int_attr(operation, "arity")?,
+            inputs: operand_symbols(operation, 0)?,
+        })
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_program_rows.rs b/crates/bolt/src/protocols/jolt/verifier_program_rows.rs
new file mode 100644
index 0000000000..f5fd950ffa
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_program_rows.rs
@@ -0,0 +1,80 @@
+use melior::ir::OperationRef;
+
+use crate::emit::rust::EmitError;
+use crate::protocols::jolt::cpu_attrs::{int_attr, string_attr, symbol_attr};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuProgramStepPlan {
+    pub kind: String,
+    pub symbol: String,
+}
+
+impl CpuProgramStepPlan {
+    pub(crate) fn new(kind: &str, symbol: String) -> Self {
+        Self {
+            kind: kind.to_owned(),
+            symbol,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuTranscriptSqueezePlan {
+    pub symbol: String,
+    pub label: String,
+    pub kind: String,
+    pub count: usize,
+}
+
+impl CpuTranscriptSqueezePlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            label: string_attr(operation, "label")?,
+            kind: string_attr(operation, "kind")?,
+            count: int_attr(operation, "count")?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuTranscriptAbsorbBytesPlan {
+    pub symbol: String,
+    pub label: String,
+    pub payload: String,
+}
+
+impl CpuTranscriptAbsorbBytesPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            label: string_attr(operation, "label")?,
+            payload: string_attr(operation, "payload")?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuOpeningInputPlan {
+    pub symbol: String,
+    pub source_stage: String,
+    pub source_claim: String,
+    pub oracle: String,
+    pub domain: String,
+    pub point_arity: usize,
+    pub claim_kind: String,
+}
+
+impl CpuOpeningInputPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            source_stage: symbol_attr(operation, "source_stage")?,
+            source_claim: symbol_attr(operation, "source_claim")?,
+            oracle: symbol_attr(operation, "oracle")?,
+            domain: symbol_attr(operation, "domain")?,
+            point_arity: int_attr(operation, "point_arity")?,
+            claim_kind: string_attr(operation, "claim_kind")?,
+        })
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs
new file mode 100644
index 0000000000..2c0bb281f6
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs
@@ -0,0 +1,2157 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use melior::ir::operation::{OperationLike, OperationResult};
+use melior::ir::OperationRef;
+
+use crate::emit::rust::EmitError;
+use crate::protocols::jolt::cpu_attrs::{
+    int_array_attr, int_attr, operation_name, optional_symbol_array_attr, string_array_attr,
+    string_attr, symbol_array_attr,
+};
+use crate::protocols::jolt::rust_target_plan::{
+    power_strided_weighted_sum_formula, structured_polynomial_scalar_formula,
+    JoltVerifierRelationKind,
+};
+use crate::protocols::jolt::verifier_values::{
+    VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointValueRef,
+    VerifierPointValueSet, VerifierScalarValueKind, VerifierScalarValuePlan,
+    VerifierScalarValueRef, VerifierScalarValueSet,
+};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StructuredPolynomialKind {
+    Eq,
+    EqPlusOne,
+    Lt,
+}
+
+impl StructuredPolynomialKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Eq => "eq",
+            Self::EqPlusOne => "eq_plus_one",
+            Self::Lt => "lt",
+        }
+    }
+
+    pub fn from_cpu_attr(value: &str) -> Result<Self, EmitError> {
+        match value {
+            "eq" => Ok(Self::Eq),
+            "eq_plus_one" => Ok(Self::EqPlusOne),
+            "lt" => Ok(Self::Lt),
+            _ => Err(EmitError::new(format!(
+                "unsupported structured polynomial `{value}`"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StructuredPolynomialPointSegment {
+    Full,
+    Prefix,
+    Suffix,
+}
+
+impl StructuredPolynomialPointSegment {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Full => "full",
+            Self::Prefix => "prefix",
+            Self::Suffix => "suffix",
+        }
+    }
+
+    pub fn from_cpu_attr(value: &str) -> Result<Self, EmitError> {
+        match value {
+            "full" => Ok(Self::Full),
+            "prefix" => Ok(Self::Prefix),
+            "suffix" => Ok(Self::Suffix),
+            _ => Err(EmitError::new(format!(
+                "unsupported structured polynomial point segment `{value}`"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StructuredPolynomialPointLength {
+    Full,
+    XPoint,
+    YPoint,
+}
+
+impl StructuredPolynomialPointLength {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Full => "full",
+            Self::XPoint => "x_point",
+            Self::YPoint => "y_point",
+        }
+    }
+
+    pub fn from_cpu_attr(value: &str) -> Result<Self, EmitError> {
+        match value {
+            "full" => Ok(Self::Full),
+            "x_point" => Ok(Self::XPoint),
+            "y_point" => Ok(Self::YPoint),
+            _ => Err(EmitError::new(format!(
+                "unsupported structured polynomial point length `{value}`"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StructuredPolynomialPointOrder {
+    AsIs,
+    Reverse,
+}
+
+impl StructuredPolynomialPointOrder {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::AsIs => "as_is",
+            Self::Reverse => "reverse",
+        }
+    }
+
+    pub fn from_cpu_attr(value: &str) -> Result<Self, EmitError> {
+        match value {
+            "as_is" => Ok(Self::AsIs),
+            "reverse" => Ok(Self::Reverse),
+            _ => Err(EmitError::new(format!(
+                "unsupported structured polynomial point order `{value}`"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RelationOutputFunctionKind {
+    BooleanZero,
+}
+
+impl RelationOutputFunctionKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::BooleanZero => "boolean_zero",
+        }
+    }
+
+    pub fn from_cpu_attr(value: &str) -> Result<Self, EmitError> {
+        match value {
+            "boolean_zero" => Ok(Self::BooleanZero),
+            _ => Err(EmitError::new(format!(
+                "unsupported relation output function `{value}`"
+            ))),
+        }
+    }
+}
+
+impl PartialEq<&str> for RelationOutputFunctionKind {
+    fn eq(&self, other: &&str) -> bool {
+        matches!((self, *other), (Self::BooleanZero, "boolean_zero"))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct StructuredPolynomialPointPlan {
+    pub source: VerifierPointValueRef,
+    pub segment: StructuredPolynomialPointSegment,
+    pub length: StructuredPolynomialPointLength,
+    pub order: StructuredPolynomialPointOrder,
+}
+
+impl StructuredPolynomialPointPlan {
+    pub fn from_cpu(
+        source: String,
+        segment: String,
+        length: String,
+        order: String,
+    ) -> Result<Self, EmitError> {
+        Ok(Self {
+            source: VerifierPointValueRef::new(source),
+            segment: StructuredPolynomialPointSegment::from_cpu_attr(&segment)?,
+            length: StructuredPolynomialPointLength::from_cpu_attr(&length)?,
+            order: StructuredPolynomialPointOrder::from_cpu_attr(&order)?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct StructuredPolynomialEvalPlan {
+    pub symbol: String,
+    pub polynomial: StructuredPolynomialKind,
+    pub x_point: StructuredPolynomialPointPlan,
+    pub y_point: StructuredPolynomialPointPlan,
+}
+
+impl StructuredPolynomialEvalPlan {
+    pub fn from_cpu(
+        symbol: String,
+        polynomial: String,
+        x_point: StructuredPolynomialPointPlan,
+        y_point: StructuredPolynomialPointPlan,
+    ) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol,
+            polynomial: StructuredPolynomialKind::from_cpu_attr(&polynomial)?,
+            x_point,
+            y_point,
+        })
+    }
+}
+
+pub fn parse_structured_polynomial_eval_plan(
+    operation: OperationRef<'_, '_>,
+) -> Result<StructuredPolynomialEvalPlan, EmitError> {
+    let x_point = StructuredPolynomialPointPlan::from_cpu(
+        operand_symbol(operation, 0)?,
+        string_attr(operation, "x_point_segment")?,
+        string_attr(operation, "x_point_length")?,
+        string_attr(operation, "x_point_order")?,
+    )?;
+    let y_point = StructuredPolynomialPointPlan::from_cpu(
+        operand_symbol(operation, 1)?,
+        string_attr(operation, "y_point_segment")?,
+        string_attr(operation, "y_point_length")?,
+        string_attr(operation, "y_point_order")?,
+    )?;
+    StructuredPolynomialEvalPlan::from_cpu(
+        string_attr(operation, "sym_name")?,
+        string_attr(operation, "polynomial")?,
+        x_point,
+        y_point,
+    )
+}
+
+pub fn structured_polynomial_scalar_expr_plan(
+    value: &StructuredPolynomialEvalPlan,
+) -> RelationOutputFieldExprPlan {
+    RelationOutputFieldExprPlan {
+        symbol: value.symbol.clone(),
+        formula: structured_polynomial_scalar_formula(
+            value.polynomial.as_str(),
+            value.x_point.segment.as_str(),
+            value.x_point.length.as_str(),
+            value.x_point.order.as_str(),
+            value.y_point.segment.as_str(),
+            value.y_point.length.as_str(),
+            value.y_point.order.as_str(),
+        ),
+        operands: vec![
+            value.x_point.source.symbol().to_owned(),
+            value.y_point.source.symbol().to_owned(),
+        ],
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputEvalFamilySharedTermPlan {
+    pub gamma_power_offset: usize,
+    pub factor: VerifierScalarValueRef,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputEvalFamilyItemTermPlan {
+    pub gamma_power_offset: usize,
+    pub factors: Vec<VerifierScalarValueRef>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputEvalFamilyPlan {
+    pub symbol: String,
+    pub gamma: VerifierScalarValueRef,
+    pub evals: Vec<VerifierScalarValueRef>,
+    pub power_stride: usize,
+    pub value_term_offsets: Vec<usize>,
+    pub shared_terms: Vec<RelationOutputEvalFamilySharedTermPlan>,
+    pub item_terms: Vec<RelationOutputEvalFamilyItemTermPlan>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputProductFamilyTermPlan {
+    pub gamma_power_offset: usize,
+    pub evals: Vec<VerifierScalarValueRef>,
+    pub eval_families: Vec<VerifierFieldVectorValueRef>,
+    pub factors: Vec<VerifierScalarValueRef>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputProductFamilyPlan {
+    pub symbol: String,
+    pub gamma: Option<VerifierScalarValueRef>,
+    pub terms: Vec<RelationOutputProductFamilyTermPlan>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputFunctionFamilyTermPlan {
+    pub gamma_power_offset: usize,
+    pub function: RelationOutputFunctionKind,
+    pub eval: VerifierScalarValueRef,
+    pub factors: Vec<VerifierScalarValueRef>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputFunctionFamilyPlan {
+    pub symbol: String,
+    pub gamma: Option<VerifierScalarValueRef>,
+    pub terms: Vec<RelationOutputFunctionFamilyTermPlan>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputPlan {
+    pub(crate) relation: JoltVerifierRelationKind,
+    local_scalars: Vec<VerifierScalarValuePlan>,
+    expected_output: VerifierScalarValueRef,
+}
+
+impl RelationOutputPlan {
+    pub(crate) fn new(
+        relation: JoltVerifierRelationKind,
+        expected_output: impl Into<String>,
+    ) -> Self {
+        Self {
+            relation,
+            local_scalars: Vec::new(),
+            expected_output: VerifierScalarValueRef::new(expected_output),
+        }
+    }
+
+    pub(crate) fn with_local_scalars(
+        relation: JoltVerifierRelationKind,
+        local_scalars: impl IntoIterator<Item = String>,
+        expected_output: impl Into<String>,
+    ) -> Self {
+        Self {
+            relation,
+            local_scalars: local_scalars
+                .into_iter()
+                .map(|symbol| {
+                    VerifierScalarValuePlan::new(
+                        symbol,
+                        VerifierScalarValueKind::RelationOutputLocal,
+                    )
+                })
+                .collect(),
+            expected_output: VerifierScalarValueRef::new(expected_output),
+        }
+    }
+
+    pub fn local_scalar_symbols(&self) -> impl Iterator<Item = &String> {
+        self.local_scalars.iter().map(|value| &value.symbol)
+    }
+
+    pub fn has_local_scalars(&self) -> bool {
+        !self.local_scalars.is_empty()
+    }
+
+    pub fn expected_output_symbol(&self) -> &str {
+        self.expected_output.symbol()
+    }
+
+    pub fn relation_symbol(&self) -> &'static str {
+        self.relation.cpu_symbol()
+    }
+
+    pub(crate) fn relation(&self) -> JoltVerifierRelationKind {
+        self.relation
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputAst {
+    pub relation: String,
+    pub polynomial_evals: Vec<String>,
+    pub polynomial_eval_operands: Vec<String>,
+    pub expected_output: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RelationOutputFieldExprPlan {
+    pub symbol: String,
+    pub formula: String,
+    pub operands: Vec<String>,
+}
+
+impl FieldExprDependencies for RelationOutputFieldExprPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn operands(&self) -> &[String] {
+        &self.operands
+    }
+}
+
+fn scalar_ref(symbol: impl Into<String>) -> VerifierScalarValueRef {
+    VerifierScalarValueRef::new(symbol)
+}
+
+fn scalar_refs(symbols: impl IntoIterator<Item = String>) -> Vec<VerifierScalarValueRef> {
+    symbols.into_iter().map(scalar_ref).collect()
+}
+
+fn scalar_ref_symbols<'a>(
+    refs: impl IntoIterator<Item = &'a VerifierScalarValueRef>,
+) -> Vec<String> {
+    refs.into_iter()
+        .map(|value_ref| value_ref.symbol().to_owned())
+        .collect()
+}
+
+pub fn parse_output_eval_family_plan(
+    stage: &str,
+    operation: OperationRef<'_, '_>,
+) -> Result<RelationOutputEvalFamilyPlan, EmitError> {
+    let symbol = string_attr(operation, "sym_name")?;
+    let evals = symbol_array_attr(operation, "evals")?;
+    let shared_factors = symbol_array_attr(operation, "shared_terms")?;
+    let item_factors = symbol_array_attr(operation, "item_terms")?;
+    let value_term_offsets = int_array_attr(operation, "value_term_offsets")?;
+    let shared_term_offsets = int_array_attr(operation, "shared_term_offsets")?;
+    let item_term_offsets = int_array_attr(operation, "item_term_offsets")?;
+    verify_count(
+        "relation output eval family shared terms",
+        &symbol,
+        shared_term_offsets.len(),
+        shared_factors.len(),
+    )?;
+    verify_count(
+        "relation output eval family item term factors",
+        &symbol,
+        item_term_offsets.len() * evals.len(),
+        item_factors.len(),
+    )?;
+    let gamma = operand_symbol(operation, 0)?;
+    let eval_operands = operand_symbols(operation, 1, 1 + evals.len())?;
+    if evals != eval_operands {
+        return Err(EmitError::new(format!(
+            "{stage} relation output eval family @{symbol} evals do not match operands"
+        )));
+    }
+    let shared_start = 1 + evals.len();
+    let shared_end = shared_start + shared_factors.len();
+    let shared_operands = operand_symbols(operation, shared_start, shared_end)?;
+    if shared_factors != shared_operands {
+        return Err(EmitError::new(format!(
+            "{stage} relation output eval family @{symbol} shared_terms do not match operands"
+        )));
+    }
+    let item_operands = operand_symbols(operation, shared_end, operation.operand_count())?;
+    if item_factors != item_operands {
+        return Err(EmitError::new(format!(
+            "{stage} relation output eval family @{symbol} item_terms do not match operands"
+        )));
+    }
+    let shared_terms = shared_term_offsets
+        .into_iter()
+        .zip(shared_factors)
+        .map(
+            |(gamma_power_offset, factor)| RelationOutputEvalFamilySharedTermPlan {
+                gamma_power_offset,
+                factor: scalar_ref(factor),
+            },
+        )
+        .collect();
+    let mut item_terms = Vec::with_capacity(item_term_offsets.len());
+    for (term_index, gamma_power_offset) in item_term_offsets.into_iter().enumerate() {
+        let start = term_index * evals.len();
+        let end = start + evals.len();
+        item_terms.push(RelationOutputEvalFamilyItemTermPlan {
+            gamma_power_offset,
+            factors: scalar_refs(item_factors[start..end].to_vec()),
+        });
+    }
+    Ok(RelationOutputEvalFamilyPlan {
+        symbol,
+        gamma: scalar_ref(gamma),
+        evals: scalar_refs(evals),
+        power_stride: int_attr(operation, "power_stride")?,
+        value_term_offsets,
+        shared_terms,
+        item_terms,
+    })
+}
+
+pub fn parse_output_product_family_plan(
+    stage: &str,
+    operation: OperationRef<'_, '_>,
+) -> Result<RelationOutputProductFamilyPlan, EmitError> {
+    let symbol = string_attr(operation, "sym_name")?;
+    let gamma = optional_symbol_array_attr(operation, "gamma")?;
+    let evals = symbol_array_attr(operation, "evals")?;
+    let factors = symbol_array_attr(operation, "factors")?;
+    let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?;
+    let term_eval_counts = int_array_attr(operation, "term_eval_counts")?;
+    let term_factor_counts = int_array_attr(operation, "term_factor_counts")?;
+    verify_count(
+        "relation output product family term eval counts",
+        &symbol,
+        term_gamma_power_offsets.len(),
+        term_eval_counts.len(),
+    )?;
+    verify_count(
+        "relation output product family term factor counts",
+        &symbol,
+        term_gamma_power_offsets.len(),
+        term_factor_counts.len(),
+    )?;
+    verify_count(
+        "relation output product family evals",
+        &symbol,
+        term_eval_counts.iter().sum(),
+        evals.len(),
+    )?;
+    verify_count(
+        "relation output product family factors",
+        &symbol,
+        term_factor_counts.iter().sum(),
+        factors.len(),
+    )?;
+    let eval_start = gamma.len();
+    if let Some(gamma_symbol) = gamma.first() {
+        let gamma_operand = operand_symbol(operation, 0)?;
+        if gamma_operand != *gamma_symbol {
+            return Err(EmitError::new(format!(
+                "{stage} relation output product family @{symbol} gamma does not match operand"
+            )));
+        }
+    }
+    let eval_end = eval_start + evals.len();
+    let eval_operands = operand_symbols(operation, eval_start, eval_end)?;
+    if evals != eval_operands {
+        return Err(EmitError::new(format!(
+            "{stage} relation output product family @{symbol} evals do not match operands"
+        )));
+    }
+    let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?;
+    if factors != factor_operands {
+        return Err(EmitError::new(format!(
+            "{stage} relation output product family @{symbol} factors do not match operands"
+        )));
+    }
+    let mut eval_offset = 0;
+    let mut factor_offset = 0;
+    let mut terms = Vec::with_capacity(term_gamma_power_offsets.len());
+    for ((gamma_power_offset, eval_count), factor_count) in term_gamma_power_offsets
+        .into_iter()
+        .zip(term_eval_counts)
+        .zip(term_factor_counts)
+    {
+        if eval_count == 0 && factor_count == 0 {
+            return Err(EmitError::new(format!(
+                "{stage} relation output product family @{symbol} has an empty term"
+            )));
+        }
+        let eval_end = eval_offset + eval_count;
+        let factor_end = factor_offset + factor_count;
+        terms.push(RelationOutputProductFamilyTermPlan {
+            gamma_power_offset,
+            evals: scalar_refs(evals[eval_offset..eval_end].to_vec()),
+            eval_families: Vec::new(),
+            factors: scalar_refs(factors[factor_offset..factor_end].to_vec()),
+        });
+        eval_offset = eval_end;
+        factor_offset = factor_end;
+    }
+    Ok(RelationOutputProductFamilyPlan {
+        symbol,
+        gamma: gamma.into_iter().next().map(scalar_ref),
+        terms,
+    })
+}
+
+pub fn parse_output_function_family_plan(
+    stage: &str,
+    operation: OperationRef<'_, '_>,
+) -> Result<RelationOutputFunctionFamilyPlan, EmitError> {
+    let symbol = string_attr(operation, "sym_name")?;
+    let gamma = optional_symbol_array_attr(operation, "gamma")?;
+    let evals = symbol_array_attr(operation, "evals")?;
+    let factors = symbol_array_attr(operation, "factors")?;
+    let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?;
+    let term_functions = string_array_attr(operation, "term_functions")?;
+    let term_factor_counts = int_array_attr(operation, "term_factor_counts")?;
+    verify_count(
+        "relation output function family term functions",
+        &symbol,
+        term_gamma_power_offsets.len(),
+        term_functions.len(),
+    )?;
+    verify_count(
+        "relation output function family term factor counts",
+        &symbol,
+        term_gamma_power_offsets.len(),
+        term_factor_counts.len(),
+    )?;
+    verify_count(
+        "relation output function family evals",
+        &symbol,
+        term_gamma_power_offsets.len(),
+        evals.len(),
+    )?;
+    verify_count(
+        "relation output function family factors",
+        &symbol,
+        term_factor_counts.iter().sum(),
+        factors.len(),
+    )?;
+    let eval_start = gamma.len();
+    if let Some(gamma_symbol) = gamma.first() {
+        let gamma_operand = operand_symbol(operation, 0)?;
+        if gamma_operand != *gamma_symbol {
+            return Err(EmitError::new(format!(
+                "{stage} relation output function family @{symbol} gamma does not match operand"
+            )));
+        }
+    }
+    let eval_end = eval_start + evals.len();
+    let eval_operands = operand_symbols(operation, eval_start, eval_end)?;
+    if evals != eval_operands {
+        return Err(EmitError::new(format!(
+            "{stage} relation output function family @{symbol} evals do not match operands"
+        )));
+    }
+    let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?;
+    if factors != factor_operands {
+        return Err(EmitError::new(format!(
+            "{stage} relation output function family @{symbol} factors do not match operands"
+        )));
+    }
+    let mut factor_offset = 0;
+    let mut terms = Vec::with_capacity(term_gamma_power_offsets.len());
+    for (((gamma_power_offset, function), eval), factor_count) in term_gamma_power_offsets
+        .into_iter()
+        .zip(term_functions)
+        .zip(evals)
+        .zip(term_factor_counts)
+    {
+        let factor_end = factor_offset + factor_count;
+        terms.push(RelationOutputFunctionFamilyTermPlan {
+            gamma_power_offset,
+            function: RelationOutputFunctionKind::from_cpu_attr(&function).map_err(|error| {
+                EmitError::new(format!(
+                    "{stage} relation output function family @{symbol}: {error}"
+                ))
+            })?,
+            eval: scalar_ref(eval),
+            factors: scalar_refs(factors[factor_offset..factor_end].to_vec()),
+        });
+        factor_offset = factor_end;
+    }
+    Ok(RelationOutputFunctionFamilyPlan {
+        symbol,
+        gamma: gamma.into_iter().next().map(scalar_ref),
+        terms,
+    })
+}
+
+pub fn lower_boolean_zero_function_family_output(
+    stage: &str,
+    relation: &str,
+    relation_output_function_families: &mut Vec<RelationOutputFunctionFamilyPlan>,
+    relation_output_asts: &mut [RelationOutputAst],
+) -> Result<Vec<RelationOutputFieldExprPlan>, EmitError> {
+    let Some(claim) = relation_output_asts
+        .iter_mut()
+        .find(|claim| claim.relation == relation)
+    else {
+        return Ok(Vec::new());
+    };
+    let family_symbol = claim.expected_output.clone();
+    let family_index = relation_output_function_families
+        .iter()
+        .position(|family| family.symbol == family_symbol)
+        .ok_or_else(|| {
+            EmitError::new(format!(
+                "{stage} relation output for @{relation} references missing function family @{family_symbol}"
+            ))
+        })?;
+    let family = relation_output_function_families[family_index].clone();
+    if family.terms.is_empty() {
+        return Err(EmitError::new(format!(
+            "{stage} relation output function family @{family_symbol} has no scalar terms"
+        )));
+    }
+
+    let prefix = relation_output_family_prefix(&family.symbol);
+    let mut rows = Vec::new();
+    let mut term_symbols = Vec::with_capacity(family.terms.len());
+    let mut gamma_powers = BTreeMap::new();
+    for (term_index, term) in family.terms.iter().enumerate() {
+        if term.function != RelationOutputFunctionKind::BooleanZero {
+            return Err(EmitError::new(format!(
+                "{stage} relation output function family @{family_symbol} has unsupported function"
+            )));
+        }
+        let square = format!("{prefix}.term{term_index}.boolean_zero.square");
+        let boolean_zero = format!("{prefix}.term{term_index}.boolean_zero");
+        rows.push(relation_output_field_expr(
+            square.clone(),
+            "field.product",
+            vec![term.eval.symbol().to_owned(), term.eval.symbol().to_owned()],
+        ));
+        rows.push(relation_output_field_expr(
+            boolean_zero.clone(),
+            "field.sub",
+            vec![square, term.eval.symbol().to_owned()],
+        ));
+        let mut operands = Vec::new();
+        if let Some(gamma) = &family.gamma {
+            if term.gamma_power_offset > 0 {
+                operands.push(eval_family_gamma_power(
+                    term.gamma_power_offset,
+                    gamma,
+                    prefix,
+                    &mut gamma_powers,
+                    &mut rows,
+                ));
+            }
+        } else if term.gamma_power_offset > 0 {
+            return Err(EmitError::new(format!(
+                "{stage} relation output function family @{family_symbol} has gamma power without gamma"
+            )));
+        }
+        operands.push(boolean_zero);
+        operands.extend(scalar_ref_symbols(&term.factors));
+        push_relation_output_product_term(
+            prefix,
+            term_index,
+            operands,
+            &mut term_symbols,
+            &mut rows,
+        );
+    }
+    let claim_expr = format!("{prefix}.claim_expr");
+    rows.push(relation_output_field_expr(
+        claim_expr.clone(),
+        "field.sum",
+        term_symbols,
+    ));
+    claim.expected_output = claim_expr;
+    let _removed_family = relation_output_function_families.remove(family_index);
+    Ok(rows)
+}
+
+pub fn lower_eval_family_output(
+    stage: &str,
+    relation: &str,
+    relation_output_eval_families: &mut Vec<RelationOutputEvalFamilyPlan>,
+    relation_output_asts: &mut [RelationOutputAst],
+) -> Result<Vec<RelationOutputFieldExprPlan>, EmitError> {
+    let Some(claim) = relation_output_asts
+        .iter_mut()
+        .find(|claim| claim.relation == relation)
+    else {
+        return Ok(Vec::new());
+    };
+    let family_symbol = claim.expected_output.clone();
+    let family_index = relation_output_eval_families
+        .iter()
+        .position(|family| family.symbol == family_symbol)
+        .ok_or_else(|| {
+            EmitError::new(format!(
+                "{stage} relation output for @{relation} references missing eval family @{family_symbol}"
+            ))
+        })?;
+    let family = relation_output_eval_families[family_index].clone();
+    for term in &family.item_terms {
+        verify_count(
+            "relation output eval family item factors",
+            &family.symbol,
+            family.evals.len(),
+            term.factors.len(),
+        )?;
+    }
+
+    let prefix = relation_output_family_prefix(&family.symbol);
+    let mut rows = Vec::new();
+    let mut term_symbols = Vec::new();
+    let mut gamma_powers = BTreeMap::new();
+    let mut term_index = 0usize;
+    for (eval_index, eval_symbol) in family.evals.iter().enumerate() {
+        let gamma_base = eval_index * family.power_stride;
+        for &offset in &family.value_term_offsets {
+            let gamma_power_offset = gamma_base + offset;
+            let operands = eval_family_term_operands(
+                eval_symbol,
+                gamma_power_offset,
+                None,
+                &family.gamma,
+                prefix,
+                &mut gamma_powers,
+                &mut rows,
+            );
+            push_relation_output_product_term(
+                prefix,
+                term_index,
+                operands,
+                &mut term_symbols,
+                &mut rows,
+            );
+            term_index += 1;
+        }
+        for term in &family.shared_terms {
+            let gamma_power_offset = gamma_base + term.gamma_power_offset;
+            let operands = eval_family_term_operands(
+                eval_symbol,
+                gamma_power_offset,
+                Some(&term.factor),
+                &family.gamma,
+                prefix,
+                &mut gamma_powers,
+                &mut rows,
+            );
+            push_relation_output_product_term(
+                prefix,
+                term_index,
+                operands,
+                &mut term_symbols,
+                &mut rows,
+            );
+            term_index += 1;
+        }
+        for term in &family.item_terms {
+            let gamma_power_offset = gamma_base + term.gamma_power_offset;
+            let operands = eval_family_term_operands(
+                eval_symbol,
+                gamma_power_offset,
+                Some(&term.factors[eval_index]),
+                &family.gamma,
+                prefix,
+                &mut gamma_powers,
+                &mut rows,
+            );
+            push_relation_output_product_term(
+                prefix,
+                term_index,
+                operands,
+                &mut term_symbols,
+                &mut rows,
+            );
+            term_index += 1;
+        }
+    }
+    if term_symbols.is_empty() {
+        return Err(EmitError::new(format!(
+            "{stage} relation output eval family @{family_symbol} has no scalar terms"
+        )));
+    }
+
+    let claim_expr = format!("{prefix}.claim_expr");
+    rows.push(relation_output_field_expr(
+        claim_expr.clone(),
+        "field.sum",
+        term_symbols,
+    ));
+    claim.expected_output = claim_expr;
+    let _removed_family = relation_output_eval_families.remove(family_index);
+    Ok(rows)
+}
+
+pub fn lower_eval_family_output_to_weighted_sum(
+    stage: &str,
+    relation: &str,
+    relation_output_eval_families: &mut Vec<RelationOutputEvalFamilyPlan>,
+    relation_output_asts: &mut [RelationOutputAst],
+) -> Result<Vec<RelationOutputFieldExprPlan>, EmitError> {
+    let Some(claim) = relation_output_asts
+        .iter_mut()
+        .find(|claim| claim.relation == relation)
+    else {
+        return Ok(Vec::new());
+    };
+    let family_symbol = claim.expected_output.clone();
+    let family_index = relation_output_eval_families
+        .iter()
+        .position(|family| family.symbol == family_symbol)
+        .ok_or_else(|| {
+            EmitError::new(format!(
+                "{stage} relation output for @{relation} references missing eval family @{family_symbol}"
+            ))
+        })?;
+    let family = relation_output_eval_families[family_index].clone();
+    if family.evals.is_empty() {
+        return Err(EmitError::new(format!(
+            "{stage} relation output eval family @{family_symbol} has no eval terms"
+        )));
+    }
+    let term_count =
+        family.value_term_offsets.len() + family.shared_terms.len() + family.item_terms.len();
+    if term_count == 0 {
+        return Err(EmitError::new(format!(
+            "{stage} relation output eval family @{family_symbol} has no scalar terms"
+        )));
+    }
+    for term in &family.item_terms {
+        verify_count(
+            "relation output eval family item factors",
+            &family.symbol,
+            family.evals.len(),
+            term.factors.len(),
+        )?;
+    }
+
+    let prefix = relation_output_family_prefix(&family.symbol);
+    let claim_expr = format!("{prefix}.claim_expr");
+    let mut operands = Vec::with_capacity(
+        1 + family.evals.len()
+            + family.shared_terms.len()
+            + family.evals.len() * family.item_terms.len(),
+    );
+    operands.push(family.gamma.symbol().to_owned());
+    operands.extend(scalar_ref_symbols(&family.evals));
+    operands.extend(
+        family
+            .shared_terms
+            .iter()
+            .map(|term| term.factor.symbol().to_owned()),
+    );
+    operands.extend(
+        family
+            .item_terms
+            .iter()
+            .flat_map(|term| term.factors.iter().map(|factor| factor.symbol().to_owned())),
+    );
+    let formula = power_strided_weighted_sum_formula(
+        family.evals.len(),
+        family.power_stride,
+        &family.value_term_offsets,
+        &family
+            .shared_terms
+            .iter()
+            .map(|term| term.gamma_power_offset)
+            .collect::<Vec<_>>(),
+        &family
+            .item_terms
+            .iter()
+            .map(|term| term.gamma_power_offset)
+            .collect::<Vec<_>>(),
+    );
+    claim.expected_output.clone_from(&claim_expr);
+    let _removed_family = relation_output_eval_families.remove(family_index);
+    Ok(vec![relation_output_field_expr(
+        claim_expr, &formula, operands,
+    )])
+}
+
+pub fn lower_product_family_output(
+    stage: &str,
+    relation: &str,
+    relation_output_product_families: &mut Vec<RelationOutputProductFamilyPlan>,
+    relation_output_asts: &mut [RelationOutputAst],
+) -> Result<Vec<RelationOutputFieldExprPlan>, EmitError> {
+    let Some(claim) = relation_output_asts
+        .iter_mut()
+        .find(|claim| claim.relation == relation)
+    else {
+        return Ok(Vec::new());
+    };
+    let family_symbol = claim.expected_output.clone();
+    let family_index = relation_output_product_families
+        .iter()
+        .position(|family| family.symbol == family_symbol)
+        .ok_or_else(|| {
+            EmitError::new(format!(
+                "{stage} relation output for @{relation} references missing product family @{family_symbol}"
+            ))
+        })?;
+    let family = relation_output_product_families[family_index].clone();
+
+    let prefix = relation_output_family_prefix(&family.symbol);
+    let mut rows = Vec::new();
+    let mut term_symbols = Vec::with_capacity(family.terms.len());
+    let mut gamma_powers = BTreeMap::new();
+    for (term_index, term) in family.terms.iter().enumerate() {
+        if !term.eval_families.is_empty() {
+            return Err(EmitError::new(format!(
+                "{stage} relation output product family @{family_symbol} requires field-vector product support"
+            )));
+        }
+        let mut operands = Vec::new();
+        if let Some(gamma) = &family.gamma {
+            if term.gamma_power_offset > 0 {
+                operands.push(eval_family_gamma_power(
+                    term.gamma_power_offset,
+                    gamma,
+                    prefix,
+                    &mut gamma_powers,
+                    &mut rows,
+                ));
+            }
+        }
+        operands.extend(scalar_ref_symbols(&term.evals));
+        operands.extend(scalar_ref_symbols(&term.factors));
+        if operands.is_empty() {
+            return Err(EmitError::new(format!(
+                "{stage} relation output product family @{family_symbol} has an empty scalar term"
+            )));
+        }
+        push_relation_output_product_term(
+            prefix,
+            term_index,
+            operands,
+            &mut term_symbols,
+            &mut rows,
+        );
+    }
+
+    let claim_expr = format!("{prefix}.claim_expr");
+    rows.push(relation_output_field_expr(
+        claim_expr.clone(),
+        "field.sum",
+        term_symbols,
+    ));
+    claim.expected_output = claim_expr;
+    let _removed_family = relation_output_product_families.remove(family_index);
+    Ok(rows)
+}
+
+fn eval_family_term_operands(
+    eval_symbol: &VerifierScalarValueRef,
+    gamma_power_offset: usize,
+    factor: Option<&VerifierScalarValueRef>,
+    gamma: &VerifierScalarValueRef,
+    prefix: &str,
+    gamma_powers: &mut BTreeMap<usize, String>,
+    rows: &mut Vec<RelationOutputFieldExprPlan>,
+) -> Vec<String> {
+    let mut operands = vec![eval_symbol.symbol().to_owned()];
+    if gamma_power_offset > 0 {
+        operands.push(eval_family_gamma_power(
+            gamma_power_offset,
+            gamma,
+            prefix,
+            gamma_powers,
+            rows,
+        ));
+    }
+    if let Some(factor) = factor {
+        operands.push(factor.symbol().to_owned());
+    }
+    operands
+}
+
+fn eval_family_gamma_power(
+    exponent: usize,
+    gamma: &VerifierScalarValueRef,
+    prefix: &str,
+    gamma_powers: &mut BTreeMap<usize, String>,
+    rows: &mut Vec<RelationOutputFieldExprPlan>,
+) -> String {
+    if let Some(symbol) = gamma_powers.get(&exponent) {
+        return symbol.clone();
+    }
+    let symbol = format!("{prefix}.gamma_pow_{exponent}");
+    rows.push(relation_output_field_expr(
+        symbol.clone(),
+        format!("field.pow:{exponent}"),
+        vec![gamma.symbol().to_owned()],
+    ));
+    let _old = gamma_powers.insert(exponent, symbol.clone());
+    symbol
+}
+
+fn push_relation_output_product_term(
+    prefix: &str,
+    term_index: usize,
+    operands: Vec<String>,
+    term_symbols: &mut Vec<String>,
+    rows: &mut Vec<RelationOutputFieldExprPlan>,
+) {
+    let symbol = format!("{prefix}.term{term_index}");
+    rows.push(relation_output_field_expr(
+        symbol.clone(),
+        "field.product",
+        operands,
+    ));
+    term_symbols.push(symbol);
+}
+
+fn relation_output_family_prefix(symbol: &str) -> &str {
+    symbol.strip_suffix(".family").unwrap_or(symbol)
+}
+
+fn relation_output_field_expr(
+    symbol: String,
+    formula: impl Into<String>,
+    operands: Vec<String>,
+) -> RelationOutputFieldExprPlan {
+    RelationOutputFieldExprPlan {
+        symbol,
+        formula: formula.into(),
+        operands,
+    }
+}
+
+pub trait FieldExprDependencies {
+    fn symbol(&self) -> &str;
+    fn operands(&self) -> &[String];
+}
+
+pub fn resolve_relation_outputs<T>(
+    stage: &str,
+    relation_output_values: &[StructuredPolynomialEvalPlan],
+    relation_output_eval_families: &[RelationOutputEvalFamilyPlan],
+    relation_output_product_families: &[RelationOutputProductFamilyPlan],
+    relation_output_function_families: &[RelationOutputFunctionFamilyPlan],
+    field_exprs: &[T],
+    claim_asts: Vec<RelationOutputAst>,
+) -> Result<Vec<RelationOutputPlan>, EmitError>
+where
+    T: FieldExprDependencies,
+{
+    let relation_output_values_by_symbol: BTreeMap<_, _> = relation_output_values
+        .iter()
+        .enumerate()
+        .map(|(index, value)| (value.symbol.as_str(), index))
+        .collect();
+    let relation_output_eval_families_by_symbol: BTreeMap<_, _> = relation_output_eval_families
+        .iter()
+        .map(|family| (family.symbol.as_str(), family))
+        .collect();
+    let relation_output_product_families_by_symbol: BTreeMap<_, _> =
+        relation_output_product_families
+            .iter()
+            .map(|family| (family.symbol.as_str(), family))
+            .collect();
+    if let Some(family) = relation_output_function_families.first() {
+        return Err(EmitError::new(format!(
+            "{stage} relation output function family @{} must be lowered before resolving relation outputs",
+            family.symbol
+        )));
+    }
+    let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs
+        .iter()
+        .map(|expr| (expr.symbol(), expr))
+        .collect();
+    claim_asts
+        .into_iter()
+        .map(|claim| {
+            verify_count(
+                "relation output polynomial_evals",
+                &claim.relation,
+                claim.polynomial_evals.len(),
+                claim.polynomial_eval_operands.len(),
+            )?;
+            if claim.polynomial_evals != claim.polynomial_eval_operands {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output for @{} polynomial_evals do not match operands",
+                    claim.relation
+                )));
+            }
+            for symbol in &claim.polynomial_evals {
+                if !relation_output_values_by_symbol.contains_key(symbol.as_str()) {
+                    return Err(EmitError::new(format!(
+                        "{stage} relation output for @{} references missing output value @{symbol}",
+                        claim.relation
+                    )));
+                }
+            }
+            let dependencies = output_dependency_closure(
+                &relation_output_eval_families_by_symbol,
+                &relation_output_product_families_by_symbol,
+                &field_exprs_by_symbol,
+                std::iter::once(claim.expected_output.as_str()),
+            );
+            if let Some(family) = dependencies.first_eval_family() {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output for @{} depends on unlowered eval family @{family}",
+                    claim.relation
+                )));
+            }
+            if let Some(family) = dependencies.first_product_family() {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output for @{} depends on unlowered product family @{family}",
+                    claim.relation
+                )));
+            }
+            let relation = JoltVerifierRelationKind::from_cpu_attr(&claim.relation)
+                .map_err(|error| EmitError::new(error.to_string()))?;
+            Ok(RelationOutputPlan::new(relation, claim.expected_output))
+        })
+        .collect()
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+enum OutputDependencyNode {
+    Scalar(String),
+    FieldExpr(String),
+    EvalFamily(String),
+    ProductFamily(String),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+enum OutputFamilyDependency {
+    Eval(String),
+    Product(String),
+}
+
+#[derive(Default)]
+struct OutputDependencyClosure {
+    families: BTreeSet<OutputFamilyDependency>,
+}
+
+impl OutputDependencyClosure {
+    fn first_eval_family(&self) -> Option<&str> {
+        self.families.iter().find_map(|family| match family {
+            OutputFamilyDependency::Eval(value) => Some(value.as_str()),
+            OutputFamilyDependency::Product(_) => None,
+        })
+    }
+
+    fn first_product_family(&self) -> Option<&str> {
+        self.families.iter().find_map(|family| match family {
+            OutputFamilyDependency::Eval(_) => None,
+            OutputFamilyDependency::Product(value) => Some(value.as_str()),
+        })
+    }
+}
+
+fn output_dependency_closure<'a, T>(
+    relation_output_eval_families_by_symbol: &BTreeMap<&str, &RelationOutputEvalFamilyPlan>,
+    relation_output_product_families_by_symbol: &BTreeMap<&str, &RelationOutputProductFamilyPlan>,
+    field_exprs_by_symbol: &BTreeMap<&str, &T>,
+    roots: impl Iterator<Item = &'a str>,
+) -> OutputDependencyClosure
+where
+    T: FieldExprDependencies,
+{
+    let mut visited = BTreeSet::new();
+    let mut dependencies = OutputDependencyClosure::default();
+    let mut stack = roots
+        .map(|symbol| {
+            output_dependency_node(
+                relation_output_eval_families_by_symbol,
+                relation_output_product_families_by_symbol,
+                field_exprs_by_symbol,
+                symbol,
+            )
+        })
+        .collect::<Vec<_>>();
+    while let Some(node) = stack.pop() {
+        if !visited.insert(node.clone()) {
+            continue;
+        }
+        match node {
+            OutputDependencyNode::Scalar(_) => {}
+            OutputDependencyNode::FieldExpr(symbol) => {
+                let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else {
+                    continue;
+                };
+                stack.extend(expr.operands().iter().map(|operand| {
+                    output_dependency_node(
+                        relation_output_eval_families_by_symbol,
+                        relation_output_product_families_by_symbol,
+                        field_exprs_by_symbol,
+                        operand,
+                    )
+                }));
+            }
+            OutputDependencyNode::EvalFamily(symbol) => {
+                let Some(family) = relation_output_eval_families_by_symbol.get(symbol.as_str())
+                else {
+                    continue;
+                };
+                let _inserted = dependencies
+                    .families
+                    .insert(OutputFamilyDependency::Eval(family.symbol.clone()));
+                stack.push(output_dependency_node(
+                    relation_output_eval_families_by_symbol,
+                    relation_output_product_families_by_symbol,
+                    field_exprs_by_symbol,
+                    family.gamma.symbol(),
+                ));
+                stack.extend(family.evals.iter().map(|eval| {
+                    output_dependency_node(
+                        relation_output_eval_families_by_symbol,
+                        relation_output_product_families_by_symbol,
+                        field_exprs_by_symbol,
+                        eval.symbol(),
+                    )
+                }));
+                stack.extend(family.shared_terms.iter().map(|term| {
+                    output_dependency_node(
+                        relation_output_eval_families_by_symbol,
+                        relation_output_product_families_by_symbol,
+                        field_exprs_by_symbol,
+                        term.factor.symbol(),
+                    )
+                }));
+                stack.extend(family.item_terms.iter().flat_map(|term| {
+                    term.factors.iter().map(|factor| {
+                        output_dependency_node(
+                            relation_output_eval_families_by_symbol,
+                            relation_output_product_families_by_symbol,
+                            field_exprs_by_symbol,
+                            factor.symbol(),
+                        )
+                    })
+                }));
+            }
+            OutputDependencyNode::ProductFamily(symbol) => {
+                let Some(family) = relation_output_product_families_by_symbol.get(symbol.as_str())
+                else {
+                    continue;
+                };
+                let _inserted = dependencies
+                    .families
+                    .insert(OutputFamilyDependency::Product(family.symbol.clone()));
+                stack.extend(family.gamma.iter().map(|gamma| {
+                    output_dependency_node(
+                        relation_output_eval_families_by_symbol,
+                        relation_output_product_families_by_symbol,
+                        field_exprs_by_symbol,
+                        gamma.symbol(),
+                    )
+                }));
+                for term in &family.terms {
+                    stack.extend(term.evals.iter().map(|eval| {
+                        output_dependency_node(
+                            relation_output_eval_families_by_symbol,
+                            relation_output_product_families_by_symbol,
+                            field_exprs_by_symbol,
+                            eval.symbol(),
+                        )
+                    }));
+                    stack.extend(term.factors.iter().map(|factor| {
+                        output_dependency_node(
+                            relation_output_eval_families_by_symbol,
+                            relation_output_product_families_by_symbol,
+                            field_exprs_by_symbol,
+                            factor.symbol(),
+                        )
+                    }));
+                }
+            }
+        }
+    }
+    dependencies
+}
+
+fn output_dependency_node(
+    relation_output_eval_families_by_symbol: &BTreeMap<&str, &RelationOutputEvalFamilyPlan>,
+    relation_output_product_families_by_symbol: &BTreeMap<&str, &RelationOutputProductFamilyPlan>,
+    field_exprs_by_symbol: &BTreeMap<&str, &impl FieldExprDependencies>,
+    symbol: &str,
+) -> OutputDependencyNode {
+    if relation_output_eval_families_by_symbol.contains_key(symbol) {
+        OutputDependencyNode::EvalFamily(symbol.to_owned())
+    } else if relation_output_product_families_by_symbol.contains_key(symbol) {
+        OutputDependencyNode::ProductFamily(symbol.to_owned())
+    } else if field_exprs_by_symbol.contains_key(symbol) {
+        OutputDependencyNode::FieldExpr(symbol.to_owned())
+    } else {
+        OutputDependencyNode::Scalar(symbol.to_owned())
+    }
+}
+
+pub fn prune_output_only_field_exprs<'a, 'b, T>(
+    field_exprs: &mut Vec<T>,
+    sumcheck_claim_roots: impl Iterator<Item = &'a str>,
+    relation_output_roots: impl Iterator<Item = &'b str>,
+) where
+    T: FieldExprDependencies,
+{
+    let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs
+        .iter()
+        .map(|expr| (expr.symbol(), expr))
+        .collect();
+    let sumcheck_claim_closure =
+        field_expr_dependency_closure(&field_exprs_by_symbol, sumcheck_claim_roots);
+    let relation_output_closure =
+        field_expr_dependency_closure(&field_exprs_by_symbol, relation_output_roots);
+    field_exprs.retain(|expr| {
+        !relation_output_closure.contains(expr.symbol())
+            || sumcheck_claim_closure.contains(expr.symbol())
+    });
+}
+
+pub struct RelationOutputVerification<'a> {
+    pub relation_output_values: &'a [StructuredPolynomialEvalPlan],
+    pub relation_output_eval_families: &'a [RelationOutputEvalFamilyPlan],
+    pub relation_output_product_families: &'a [RelationOutputProductFamilyPlan],
+    pub relation_output_function_families: &'a [RelationOutputFunctionFamilyPlan],
+    pub relation_outputs: &'a [RelationOutputPlan],
+    pub relations: &'a BTreeSet<JoltVerifierRelationKind>,
+    pub field_values: &'a VerifierScalarValueSet,
+    pub field_vector_values: &'a VerifierFieldVectorValueSet,
+    pub point_values: &'a VerifierPointValueSet,
+}
+
+pub fn verify_relation_outputs(
+    stage: &str,
+    verification: RelationOutputVerification<'_>,
+) -> Result<(), EmitError> {
+    let RelationOutputVerification {
+        relation_output_values,
+        relation_output_eval_families,
+        relation_output_product_families,
+        relation_output_function_families,
+        relation_outputs,
+        relations,
+        field_values,
+        field_vector_values,
+        point_values,
+    } = verification;
+    field_values.verify_no_conflicts(stage)?;
+    point_values.verify_no_conflicts(stage)?;
+    for polynomial_eval in relation_output_values {
+        if !point_values.contains_ref(&polynomial_eval.x_point.source) {
+            return Err(EmitError::new(format!(
+                "{stage} structured polynomial eval @{} references missing x-point @{}",
+                polynomial_eval.symbol,
+                polynomial_eval.x_point.source.symbol()
+            )));
+        }
+        if !point_values.contains_ref(&polynomial_eval.y_point.source) {
+            return Err(EmitError::new(format!(
+                "{stage} structured polynomial eval @{} references missing y-point @{}",
+                polynomial_eval.symbol,
+                polynomial_eval.y_point.source.symbol()
+            )));
+        }
+    }
+    for family in relation_output_eval_families {
+        if !field_values.contains_ref(&family.gamma) {
+            return Err(EmitError::new(format!(
+                "{stage} relation output eval family @{} references missing gamma @{}",
+                family.symbol,
+                family.gamma.symbol()
+            )));
+        }
+        for eval in &family.evals {
+            if !field_values.contains_ref(eval) {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output eval family @{} references missing eval @{}",
+                    family.symbol,
+                    eval.symbol()
+                )));
+            }
+        }
+        for term in &family.shared_terms {
+            if !field_values.contains_ref(&term.factor) {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output eval family @{} references missing shared factor @{}",
+                    family.symbol,
+                    term.factor.symbol()
+                )));
+            }
+        }
+        for term in &family.item_terms {
+            verify_count(
+                "relation output eval family item factors",
+                &family.symbol,
+                family.evals.len(),
+                term.factors.len(),
+            )?;
+            for factor in &term.factors {
+                if !field_values.contains_ref(factor) {
+                    return Err(EmitError::new(format!(
+                        "{stage} relation output eval family @{} references missing item factor @{}",
+                        family.symbol,
+                        factor.symbol()
+                    )));
+                }
+            }
+        }
+    }
+    for family in relation_output_product_families {
+        if let Some(gamma) = &family.gamma {
+            if !field_values.contains_ref(gamma) {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output product family @{} references missing gamma @{}",
+                    family.symbol,
+                    gamma.symbol()
+                )));
+            }
+        }
+        for term in &family.terms {
+            if term.evals.is_empty() && term.eval_families.is_empty() && term.factors.is_empty() {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output product family @{} has an empty term",
+                    family.symbol
+                )));
+            }
+            for eval_family in &term.eval_families {
+                if !field_vector_values.contains_ref(eval_family) {
+                    return Err(EmitError::new(format!(
+                        "{stage} relation output product family @{} references missing eval family @{}",
+                        family.symbol,
+                        eval_family.symbol()
+                    )));
+                }
+            }
+            for eval in &term.evals {
+                if !field_values.contains_ref(eval) {
+                    return Err(EmitError::new(format!(
+                        "{stage} relation output product family @{} references missing eval @{}",
+                        family.symbol,
+                        eval.symbol()
+                    )));
+                }
+            }
+            for factor in &term.factors {
+                if !field_values.contains_ref(factor) {
+                    return Err(EmitError::new(format!(
+                        "{stage} relation output product family @{} references missing factor @{}",
+                        family.symbol,
+                        factor.symbol()
+                    )));
+                }
+            }
+        }
+    }
+    for family in relation_output_function_families {
+        if let Some(gamma) = &family.gamma {
+            if !field_values.contains_ref(gamma) {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output function family @{} references missing gamma @{}",
+                    family.symbol,
+                    gamma.symbol()
+                )));
+            }
+        }
+        for term in &family.terms {
+            if !field_values.contains_ref(&term.eval) {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output function family @{} references missing eval @{}",
+                    family.symbol,
+                    term.eval.symbol()
+                )));
+            }
+            for factor in &term.factors {
+                if !field_values.contains_ref(factor) {
+                    return Err(EmitError::new(format!(
+                        "{stage} relation output function family @{} references missing factor @{}",
+                        family.symbol,
+                        factor.symbol()
+                    )));
+                }
+            }
+        }
+    }
+    for claim in relation_outputs {
+        if !relations.contains(&claim.relation) {
+            return Err(EmitError::new(format!(
+                "{stage} relation output references missing relation @{}",
+                claim.relation.cpu_symbol()
+            )));
+        }
+        let expected_output = claim.expected_output_symbol();
+        if !field_values.contains_ref(&claim.expected_output) {
+            return Err(EmitError::new(format!(
+                "{stage} relation output for @{} uses missing expected output @{}",
+                claim.relation.cpu_symbol(),
+                expected_output
+            )));
+        }
+        for local_scalar in &claim.local_scalars {
+            if !field_values.contains_plan(local_scalar) {
+                return Err(EmitError::new(format!(
+                    "{stage} relation output for @{} references missing local scalar @{}",
+                    claim.relation.cpu_symbol(),
+                    local_scalar.symbol
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn field_expr_dependency_closure<'a, T>(
+    field_exprs_by_symbol: &BTreeMap<&str, &T>,
+    roots: impl Iterator<Item = &'a str>,
+) -> BTreeSet<String>
+where
+    T: FieldExprDependencies,
+{
+    let mut visited = BTreeSet::new();
+    let mut stack = roots.map(str::to_owned).collect::<Vec<_>>();
+    while let Some(symbol) = stack.pop() {
+        if !visited.insert(symbol.clone()) {
+            continue;
+        }
+        let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else {
+            continue;
+        };
+        for operand in expr.operands() {
+            if field_exprs_by_symbol.contains_key(operand.as_str()) {
+                stack.push(operand.clone());
+            }
+        }
+    }
+    visited
+}
+
+fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Result<(), EmitError> {
+    if expected == actual {
+        Ok(())
+    } else {
+        Err(EmitError::new(format!(
+            "{kind} @{symbol} count mismatch: expected {expected}, got {actual}"
+        )))
+    }
+}
+
+fn operand_symbols(
+    operation: OperationRef<'_, '_>,
+    start_index: usize,
+    end_index: usize,
+) -> Result<Vec<String>, EmitError> {
+    (start_index..end_index)
+        .map(|index| operand_symbol(operation, index))
+        .collect()
+}
+
+fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result<String, EmitError> {
+    let operand = operation.operand(index).map_err(|_| {
+        EmitError::new(format!(
+            "{} requires operand {index}",
+            operation_name(operation)
+        ))
+    })?;
+    let owner = OperationResult::try_from(operand).map_err(|_| {
+        EmitError::new(format!(
+            "{} operand {index} must be an op result",
+            operation_name(operation)
+        ))
+    })?;
+    string_attr(owner.owner(), "sym_name")
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+
+    use crate::emit::rust::EmitError;
+    use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind;
+    use crate::protocols::jolt::verifier_values::{
+        VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointValueKind,
+        VerifierPointValueRef, VerifierPointValueSet, VerifierScalarValueKind,
+        VerifierScalarValueSet,
+    };
+
+    use super::{
+        resolve_relation_outputs, scalar_ref, scalar_refs, verify_relation_outputs,
+        FieldExprDependencies, RelationOutputAst, RelationOutputEvalFamilyItemTermPlan,
+        RelationOutputEvalFamilyPlan, RelationOutputEvalFamilySharedTermPlan,
+        RelationOutputFunctionFamilyPlan, RelationOutputFunctionFamilyTermPlan,
+        RelationOutputFunctionKind, RelationOutputPlan, RelationOutputProductFamilyPlan,
+        RelationOutputProductFamilyTermPlan, RelationOutputVerification,
+        StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength,
+        StructuredPolynomialPointOrder, StructuredPolynomialPointPlan,
+        StructuredPolynomialPointSegment,
+    };
+
+    struct TestFieldExpr {
+        symbol: String,
+        operands: Vec<String>,
+    }
+
+    impl FieldExprDependencies for TestFieldExpr {
+        fn symbol(&self) -> &str {
+            &self.symbol
+        }
+
+        fn operands(&self) -> &[String] {
+            &self.operands
+        }
+    }
+
+    #[test]
+    fn structured_polynomial_scalar_expr_plan_preserves_typed_point_transforms() {
+        let value = StructuredPolynomialEvalPlan {
+            symbol: "eq.output".to_owned(),
+            polynomial: StructuredPolynomialKind::EqPlusOne,
+            x_point: StructuredPolynomialPointPlan {
+                source: VerifierPointValueRef::new("x.source"),
+                segment: StructuredPolynomialPointSegment::Prefix,
+                length: StructuredPolynomialPointLength::YPoint,
+                order: StructuredPolynomialPointOrder::Reverse,
+            },
+            y_point: StructuredPolynomialPointPlan {
+                source: VerifierPointValueRef::new("y.source"),
+                segment: StructuredPolynomialPointSegment::Full,
+                length: StructuredPolynomialPointLength::Full,
+                order: StructuredPolynomialPointOrder::AsIs,
+            },
+        };
+
+        let expr = super::structured_polynomial_scalar_expr_plan(&value);
+
+        assert_eq!(expr.symbol, "eq.output");
+        assert_eq!(
+            expr.formula,
+            "poly.structured_eval:eq_plus_one:prefix:y_point:reverse:full:full:as_is"
+        );
+        assert_eq!(
+            expr.operands,
+            vec!["x.source".to_owned(), "y.source".to_owned()]
+        );
+    }
+
+    #[test]
+    fn resolve_rejects_unlowered_eval_families_reachable_through_field_expressions(
+    ) -> Result<(), EmitError> {
+        let inner_family = RelationOutputEvalFamilyPlan {
+            symbol: "inner.family".to_owned(),
+            gamma: scalar_ref("inner.gamma"),
+            evals: scalar_refs(["inner.eval".to_owned()]),
+            power_stride: 1,
+            value_term_offsets: vec![0],
+            shared_terms: Vec::new(),
+            item_terms: Vec::new(),
+        };
+        let outer_family = RelationOutputEvalFamilyPlan {
+            symbol: "outer.family".to_owned(),
+            gamma: scalar_ref("outer.gamma"),
+            evals: scalar_refs(["outer.eval".to_owned()]),
+            power_stride: 1,
+            value_term_offsets: Vec::new(),
+            shared_terms: vec![RelationOutputEvalFamilySharedTermPlan {
+                gamma_power_offset: 0,
+                factor: scalar_ref("outer.shared.factor"),
+            }],
+            item_terms: vec![RelationOutputEvalFamilyItemTermPlan {
+                gamma_power_offset: 1,
+                factors: scalar_refs(["factor.expr".to_owned()]),
+            }],
+        };
+        let field_exprs = vec![
+            TestFieldExpr {
+                symbol: "claim.expr".to_owned(),
+                operands: vec!["outer.family".to_owned()],
+            },
+            TestFieldExpr {
+                symbol: "factor.expr".to_owned(),
+                operands: vec!["inner.family".to_owned()],
+            },
+        ];
+        let claim_asts = vec![RelationOutputAst {
+            relation: "relation".to_owned(),
+            polynomial_evals: Vec::new(),
+            polynomial_eval_operands: Vec::new(),
+            expected_output: "claim.expr".to_owned(),
+        }];
+
+        let error = match resolve_relation_outputs(
+            "test",
+            &[],
+            &[inner_family, outer_family],
+            &[],
+            &[],
+            &field_exprs,
+            claim_asts,
+        ) {
+            Ok(_) => {
+                return Err(EmitError::new(
+                    "unlowered eval family should fail relation output resolution",
+                ));
+            }
+            Err(error) => error,
+        };
+        assert!(error.to_string().contains(
+            "test relation output for @relation depends on unlowered eval family @inner.family"
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_rejects_unlowered_product_families_reachable_through_field_expressions(
+    ) -> Result<(), EmitError> {
+        let product_family = RelationOutputProductFamilyPlan {
+            symbol: "product.family".to_owned(),
+            gamma: Some(scalar_ref("product.gamma")),
+            terms: vec![RelationOutputProductFamilyTermPlan {
+                gamma_power_offset: 2,
+                evals: scalar_refs(["product.eval".to_owned()]),
+                eval_families: Vec::new(),
+                factors: scalar_refs(["product.factor.expr".to_owned()]),
+            }],
+        };
+        let field_exprs = vec![
+            TestFieldExpr {
+                symbol: "claim.expr".to_owned(),
+                operands: vec!["product.family".to_owned()],
+            },
+            TestFieldExpr {
+                symbol: "product.factor.expr".to_owned(),
+                operands: vec!["unrelated.scalar".to_owned()],
+            },
+        ];
+        let claim_asts = vec![RelationOutputAst {
+            relation: "relation".to_owned(),
+            polynomial_evals: Vec::new(),
+            polynomial_eval_operands: Vec::new(),
+            expected_output: "claim.expr".to_owned(),
+        }];
+
+        let error = match resolve_relation_outputs(
+            "test",
+            &[],
+            &[],
+            &[product_family],
+            &[],
+            &field_exprs,
+            claim_asts,
+        ) {
+            Ok(_) => {
+                return Err(EmitError::new(
+                    "unlowered product family should fail relation output resolution",
+                ));
+            }
+            Err(error) => error,
+        };
+        assert!(error.to_string().contains(
+            "test relation output for @relation depends on unlowered product family @product.family"
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_rejects_unlowered_function_families() -> Result<(), EmitError> {
+        let function_family = RelationOutputFunctionFamilyPlan {
+            symbol: "function.family".to_owned(),
+            gamma: Some(scalar_ref("function.gamma")),
+            terms: vec![RelationOutputFunctionFamilyTermPlan {
+                gamma_power_offset: 0,
+                function: RelationOutputFunctionKind::BooleanZero,
+                eval: scalar_ref("function.eval"),
+                factors: scalar_refs(["function.factor.expr".to_owned()]),
+            }],
+        };
+        let claim_asts = vec![RelationOutputAst {
+            relation: "relation".to_owned(),
+            polynomial_evals: Vec::new(),
+            polynomial_eval_operands: Vec::new(),
+            expected_output: "function.family".to_owned(),
+        }];
+
+        let error = match resolve_relation_outputs(
+            "test",
+            &[],
+            &[],
+            &[],
+            &[function_family],
+            &[] as &[TestFieldExpr],
+            claim_asts,
+        ) {
+            Ok(_) => {
+                return Err(EmitError::new(
+                    "unlowered function family should fail relation output resolution",
+                ));
+            }
+            Err(error) => error,
+        };
+        assert!(error
+            .to_string()
+            .contains("test relation output function family @function.family must be lowered"));
+        Ok(())
+    }
+
+    #[test]
+    fn relation_output_verification_rejects_conflicting_scalar_values() -> Result<(), EmitError> {
+        let mut field_values = VerifierScalarValueSet::default();
+        field_values.insert("value", VerifierScalarValueKind::OpeningInput);
+        field_values.insert("value", VerifierScalarValueKind::FieldExpr);
+        let field_vector_values = VerifierFieldVectorValueSet::default();
+        let point_values = VerifierPointValueSet::default();
+        let relations = BTreeSet::new();
+
+        let error = match verify_relation_outputs(
+            "stage",
+            RelationOutputVerification {
+                relation_output_values: &[],
+                relation_output_eval_families: &[],
+                relation_output_product_families: &[],
+                relation_output_function_families: &[],
+                relation_outputs: &[],
+                relations: &relations,
+                field_values: &field_values,
+                field_vector_values: &field_vector_values,
+                point_values: &point_values,
+            },
+        ) {
+            Ok(()) => {
+                return Err(EmitError::new(
+                    "conflicting scalar sources should fail verification",
+                ));
+            }
+            Err(error) => error,
+        };
+
+        assert!(error.to_string().contains(
+            "stage scalar value source @value has conflicting kinds OpeningInput and FieldExpr"
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn relation_output_verification_rejects_conflicting_point_values() -> Result<(), EmitError> {
+        let field_values = VerifierScalarValueSet::default();
+        let field_vector_values = VerifierFieldVectorValueSet::default();
+        let mut point_values = VerifierPointValueSet::default();
+        point_values.insert("point", VerifierPointValueKind::OpeningInput);
+        point_values.insert("point", VerifierPointValueKind::PointExpr);
+        let relations = BTreeSet::new();
+
+        let error = match verify_relation_outputs(
+            "stage",
+            RelationOutputVerification {
+                relation_output_values: &[],
+                relation_output_eval_families: &[],
+                relation_output_product_families: &[],
+                relation_output_function_families: &[],
+                relation_outputs: &[],
+                relations: &relations,
+                field_values: &field_values,
+                field_vector_values: &field_vector_values,
+                point_values: &point_values,
+            },
+        ) {
+            Ok(()) => {
+                return Err(EmitError::new(
+                    "conflicting point sources should fail verification",
+                ));
+            }
+            Err(error) => error,
+        };
+
+        assert!(error.to_string().contains(
+            "stage point value source @point has conflicting kinds OpeningInput and PointExpr"
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn relation_output_verification_requires_planned_point_refs() -> Result<(), EmitError> {
+        let field_values = VerifierScalarValueSet::default();
+        let field_vector_values = VerifierFieldVectorValueSet::default();
+        let mut point_values = VerifierPointValueSet::default();
+        point_values.insert("point.y", VerifierPointValueKind::OpeningInput);
+        let relations = BTreeSet::new();
+        let relation_output_values = [StructuredPolynomialEvalPlan {
+            symbol: "eq.output".to_owned(),
+            polynomial: StructuredPolynomialKind::Eq,
+            x_point: StructuredPolynomialPointPlan {
+                source: VerifierPointValueRef::new("missing.point"),
+                segment: StructuredPolynomialPointSegment::Full,
+                length: StructuredPolynomialPointLength::Full,
+                order: StructuredPolynomialPointOrder::AsIs,
+            },
+            y_point: StructuredPolynomialPointPlan {
+                source: VerifierPointValueRef::new("point.y"),
+                segment: StructuredPolynomialPointSegment::Full,
+                length: StructuredPolynomialPointLength::Full,
+                order: StructuredPolynomialPointOrder::AsIs,
+            },
+        }];
+
+        let error = match verify_relation_outputs(
+            "stage",
+            RelationOutputVerification {
+                relation_output_values: &relation_output_values,
+                relation_output_eval_families: &[],
+                relation_output_product_families: &[],
+                relation_output_function_families: &[],
+                relation_outputs: &[],
+                relations: &relations,
+                field_values: &field_values,
+                field_vector_values: &field_vector_values,
+                point_values: &point_values,
+            },
+        ) {
+            Ok(()) => {
+                return Err(EmitError::new(
+                    "missing point ref should fail relation output verification",
+                ));
+            }
+            Err(error) => error,
+        };
+
+        assert!(error.to_string().contains(
+            "stage structured polynomial eval @eq.output references missing x-point @missing.point"
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn relation_output_verification_requires_planned_local_scalars() -> Result<(), EmitError> {
+        let mut field_values = VerifierScalarValueSet::default();
+        field_values.insert("claim", VerifierScalarValueKind::FieldExpr);
+        let field_vector_values = VerifierFieldVectorValueSet::default();
+        let point_values = VerifierPointValueSet::default();
+        let relations = BTreeSet::from([JoltVerifierRelationKind::Stage3Batched]);
+        let relation_outputs = [RelationOutputPlan::with_local_scalars(
+            JoltVerifierRelationKind::Stage3Batched,
+            ["local.scalar".to_owned()],
+            "claim",
+        )];
+
+        let error = match verify_relation_outputs(
+            "stage",
+            RelationOutputVerification {
+                relation_output_values: &[],
+                relation_output_eval_families: &[],
+                relation_output_product_families: &[],
+                relation_output_function_families: &[],
+                relation_outputs: &relation_outputs,
+                relations: &relations,
+                field_values: &field_values,
+                field_vector_values: &field_vector_values,
+                point_values: &point_values,
+            },
+        ) {
+            Ok(()) => {
+                return Err(EmitError::new(
+                    "unplanned local scalar should fail relation output verification",
+                ));
+            }
+            Err(error) => error,
+        };
+
+        assert!(error.to_string().contains(
+            "stage relation output for @jolt.stage3.batched references missing local scalar @local.scalar"
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn relation_output_verification_requires_planned_family_scalar_refs() -> Result<(), EmitError> {
+        let mut field_values = VerifierScalarValueSet::default();
+        field_values.insert("family.gamma", VerifierScalarValueKind::TranscriptScalar);
+        field_values.insert("family.eval", VerifierScalarValueKind::SumcheckEval);
+        let field_vector_values = VerifierFieldVectorValueSet::default();
+        let point_values = VerifierPointValueSet::default();
+        let relations = BTreeSet::new();
+        let family = RelationOutputEvalFamilyPlan {
+            symbol: "family".to_owned(),
+            gamma: scalar_ref("family.gamma"),
+            evals: scalar_refs(["family.eval".to_owned()]),
+            power_stride: 1,
+            value_term_offsets: Vec::new(),
+            shared_terms: vec![RelationOutputEvalFamilySharedTermPlan {
+                gamma_power_offset: 0,
+                factor: scalar_ref("missing.factor"),
+            }],
+            item_terms: Vec::new(),
+        };
+
+        let error = match verify_relation_outputs(
+            "stage",
+            RelationOutputVerification {
+                relation_output_values: &[],
+                relation_output_eval_families: &[family],
+                relation_output_product_families: &[],
+                relation_output_function_families: &[],
+                relation_outputs: &[],
+                relations: &relations,
+                field_values: &field_values,
+                field_vector_values: &field_vector_values,
+                point_values: &point_values,
+            },
+        ) {
+            Ok(()) => {
+                return Err(EmitError::new(
+                    "missing family scalar ref should fail relation output verification",
+                ));
+            }
+            Err(error) => error,
+        };
+
+        assert!(error.to_string().contains(
+            "stage relation output eval family @family references missing shared factor @missing.factor"
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn relation_output_verification_requires_planned_field_vector_refs() -> Result<(), EmitError> {
+        let field_values = VerifierScalarValueSet::default();
+        let field_vector_values = VerifierFieldVectorValueSet::default();
+        let point_values = VerifierPointValueSet::default();
+        let relations = BTreeSet::new();
+        let family = RelationOutputProductFamilyPlan {
+            symbol: "product.family".to_owned(),
+            gamma: None,
+            terms: vec![RelationOutputProductFamilyTermPlan {
+                gamma_power_offset: 0,
+                evals: Vec::new(),
+                eval_families: vec![VerifierFieldVectorValueRef::new("missing.eval.family")],
+                factors: Vec::new(),
+            }],
+        };
+
+        let error = match verify_relation_outputs(
+            "stage",
+            RelationOutputVerification {
+                relation_output_values: &[],
+                relation_output_eval_families: &[],
+                relation_output_product_families: &[family],
+                relation_output_function_families: &[],
+                relation_outputs: &[],
+                relations: &relations,
+                field_values: &field_values,
+                field_vector_values: &field_vector_values,
+                point_values: &point_values,
+            },
+        ) {
+            Ok(()) => {
+                return Err(EmitError::new(
+                    "missing field-vector ref should fail relation output verification",
+                ));
+            }
+            Err(error) => error,
+        };
+
+        assert!(error.to_string().contains(
+            "stage relation output product family @product.family references missing eval family @missing.eval.family"
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn relation_output_verification_requires_relation_local_scalar_kind() -> Result<(), EmitError> {
+        let mut field_values = VerifierScalarValueSet::default();
+        field_values.insert("claim", VerifierScalarValueKind::FieldExpr);
+        field_values.insert("local.scalar", VerifierScalarValueKind::FieldExpr);
+        let field_vector_values = VerifierFieldVectorValueSet::default();
+        let point_values = VerifierPointValueSet::default();
+        let relations = BTreeSet::from([JoltVerifierRelationKind::Stage3Batched]);
+        let relation_outputs = [RelationOutputPlan::with_local_scalars(
+            JoltVerifierRelationKind::Stage3Batched,
+            ["local.scalar".to_owned()],
+            "claim",
+        )];
+
+        let error = match verify_relation_outputs(
+            "stage",
+            RelationOutputVerification {
+                relation_output_values: &[],
+                relation_output_eval_families: &[],
+                relation_output_product_families: &[],
+                relation_output_function_families: &[],
+                relation_outputs: &relation_outputs,
+                relations: &relations,
+                field_values: &field_values,
+                field_vector_values: &field_vector_values,
+                point_values: &point_values,
+            },
+        ) {
+            Ok(()) => {
+                return Err(EmitError::new(
+                    "wrong local scalar value kind should fail relation output verification",
+                ));
+            }
+            Err(error) => error,
+        };
+
+        assert!(error.to_string().contains(
+            "stage relation output for @jolt.stage3.batched references missing local scalar @local.scalar"
+        ));
+        Ok(())
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_sumcheck_rows.rs b/crates/bolt/src/protocols/jolt/verifier_sumcheck_rows.rs
new file mode 100644
index 0000000000..491da60bb8
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_sumcheck_rows.rs
@@ -0,0 +1,188 @@
+use melior::ir::OperationRef;
+
+use crate::emit::rust::EmitError;
+use crate::protocols::jolt::cpu_attrs::{
+    int_array_attr, int_attr, operand_symbol, operand_symbols, string_attr, symbol_array_attr,
+    symbol_attr,
+};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuSumcheckClaimPlan {
+    pub symbol: String,
+    pub stage: String,
+    pub domain: String,
+    pub num_rounds: usize,
+    pub degree: usize,
+    pub claim: String,
+    pub kernel: Option<String>,
+    pub relation: Option<String>,
+    pub claim_value: String,
+    pub input_openings: Vec<String>,
+}
+
+impl CpuSumcheckClaimPlan {
+    pub(crate) fn from_claim(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            stage: symbol_attr(operation, "stage")?,
+            domain: symbol_attr(operation, "domain")?,
+            num_rounds: int_attr(operation, "num_rounds")?,
+            degree: int_attr(operation, "degree")?,
+            claim: symbol_attr(operation, "claim")?,
+            kernel: Some(symbol_attr(operation, "kernel")?),
+            relation: None,
+            claim_value: operand_symbol(operation, 0)?,
+            input_openings: operand_symbols(operation, 1)?,
+        })
+    }
+
+    pub(crate) fn from_verify_claim(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            stage: symbol_attr(operation, "stage")?,
+            domain: symbol_attr(operation, "domain")?,
+            num_rounds: int_attr(operation, "num_rounds")?,
+            degree: int_attr(operation, "degree")?,
+            claim: symbol_attr(operation, "claim")?,
+            kernel: None,
+            relation: Some(symbol_attr(operation, "relation")?),
+            claim_value: operand_symbol(operation, 0)?,
+            input_openings: operand_symbols(operation, 1)?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuSumcheckBatchPlan {
+    pub symbol: String,
+    pub stage: String,
+    pub proof_slot: String,
+    pub policy: String,
+    pub count: usize,
+    pub ordered_claims: Vec<String>,
+    pub claim_operands: Vec<String>,
+    pub claim_label: String,
+    pub round_label: String,
+    pub round_schedule: Vec<usize>,
+}
+
+impl CpuSumcheckBatchPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            stage: symbol_attr(operation, "stage")?,
+            proof_slot: symbol_attr(operation, "proof_slot")?,
+            policy: string_attr(operation, "policy")?,
+            count: int_attr(operation, "count")?,
+            ordered_claims: symbol_array_attr(operation, "ordered_claims")?,
+            claim_operands: operand_symbols(operation, 0)?,
+            claim_label: string_attr(operation, "claim_label")?,
+            round_label: string_attr(operation, "round_label")?,
+            round_schedule: int_array_attr(operation, "round_schedule")?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuSumcheckDriverPlan {
+    pub symbol: String,
+    pub stage: String,
+    pub proof_slot: String,
+    pub kernel: Option<String>,
+    pub relation: Option<String>,
+    pub batch: String,
+    pub policy: String,
+    pub round_schedule: Vec<usize>,
+    pub claim_label: String,
+    pub round_label: String,
+    pub num_rounds: usize,
+    pub degree: usize,
+}
+
+impl CpuSumcheckDriverPlan {
+    pub(crate) fn from_driver(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            stage: symbol_attr(operation, "stage")?,
+            proof_slot: symbol_attr(operation, "proof_slot")?,
+            kernel: Some(symbol_attr(operation, "kernel")?),
+            relation: None,
+            batch: operand_symbol(operation, 1)?,
+            policy: string_attr(operation, "policy")?,
+            round_schedule: int_array_attr(operation, "round_schedule")?,
+            claim_label: string_attr(operation, "claim_label")?,
+            round_label: string_attr(operation, "round_label")?,
+            num_rounds: int_attr(operation, "num_rounds")?,
+            degree: int_attr(operation, "degree")?,
+        })
+    }
+
+    pub(crate) fn from_verify(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            stage: symbol_attr(operation, "stage")?,
+            proof_slot: symbol_attr(operation, "proof_slot")?,
+            kernel: None,
+            relation: Some(symbol_attr(operation, "relation")?),
+            batch: operand_symbol(operation, 1)?,
+            policy: string_attr(operation, "policy")?,
+            round_schedule: int_array_attr(operation, "round_schedule")?,
+            claim_label: string_attr(operation, "claim_label")?,
+            round_label: string_attr(operation, "round_label")?,
+            num_rounds: int_attr(operation, "num_rounds")?,
+            degree: int_attr(operation, "degree")?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuSumcheckInstanceResultPlan {
+    pub symbol: String,
+    pub source: String,
+    pub claim: String,
+    pub relation: String,
+    pub index: usize,
+    pub point_arity: usize,
+    pub num_rounds: usize,
+    pub round_offset: usize,
+    pub point_order: String,
+    pub degree: usize,
+}
+
+impl CpuSumcheckInstanceResultPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            source: symbol_attr(operation, "source")?,
+            claim: symbol_attr(operation, "claim")?,
+            relation: symbol_attr(operation, "relation")?,
+            index: int_attr(operation, "index")?,
+            point_arity: int_attr(operation, "point_arity")?,
+            num_rounds: int_attr(operation, "num_rounds")?,
+            round_offset: int_attr(operation, "round_offset")?,
+            point_order: string_attr(operation, "point_order")?,
+            degree: int_attr(operation, "degree")?,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuSumcheckEvalPlan {
+    pub symbol: String,
+    pub source: String,
+    pub name: String,
+    pub index: usize,
+    pub oracle: String,
+}
+
+impl CpuSumcheckEvalPlan {
+    pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            source: symbol_attr(operation, "source")?,
+            name: symbol_attr(operation, "name")?,
+            index: int_attr(operation, "index")?,
+            oracle: symbol_attr(operation, "oracle")?,
+        })
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_value_rows.rs b/crates/bolt/src/protocols/jolt/verifier_value_rows.rs
new file mode 100644
index 0000000000..daf1ca3644
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_value_rows.rs
@@ -0,0 +1,117 @@
+use melior::ir::OperationRef;
+
+use crate::emit::rust::EmitError;
+use crate::protocols::jolt::cpu_attrs::{
+    int_attr, operand_symbols, operation_name, signed_int_attr, string_attr, symbol_attr,
+};
+use crate::protocols::jolt::verifier_relation_outputs::FieldExprDependencies;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuFieldConstantPlan {
+    pub symbol: String,
+    pub field: String,
+    pub value: usize,
+}
+
+impl CpuFieldConstantPlan {
+    pub(crate) fn from_const(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Self::from_value(operation, int_attr(operation, "value")?)
+    }
+
+    pub(crate) fn from_zero(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Self::from_value(operation, 0)
+    }
+
+    pub(crate) fn from_one(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Self::from_value(operation, 1)
+    }
+
+    fn from_value(operation: OperationRef<'_, '_>, value: usize) -> Result<Self, EmitError> {
+        Ok(Self {
+            symbol: string_attr(operation, "sym_name")?,
+            field: symbol_attr(operation, "field")?,
+            value,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuFieldExprPlan {
+    pub symbol: String,
+    pub kind: String,
+    pub formula: String,
+    pub operand_names: Vec<String>,
+    pub operands: Vec<String>,
+}
+
+impl CpuFieldExprPlan {
+    pub(crate) fn from_field_op(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self::op(
+            string_attr(operation, "sym_name")?,
+            operation_name(operation).replace("cpu.field_", "field."),
+            operand_symbols(operation, 0)?,
+        ))
+    }
+
+    pub(crate) fn from_field_pow(operation: OperationRef<'_, '_>) -> Result<Self, EmitError> {
+        Ok(Self::op(
+            string_attr(operation, "sym_name")?,
+            format!("field.pow:{}", int_attr(operation, "exponent")?),
+            operand_symbols(operation, 0)?,
+        ))
+    }
+
+    pub(crate) fn from_lagrange_basis_eval(
+        operation: OperationRef<'_, '_>,
+    ) -> Result<Self, EmitError> {
+        let domain_start = signed_int_attr(operation, "domain_start")?;
+        let domain_size = int_attr(operation, "domain_size")?;
+        let index = int_attr(operation, "index")?;
+        Ok(Self::op(
+            string_attr(operation, "sym_name")?,
+            format!("poly.lagrange_basis_eval:{domain_start}:{domain_size}:{index}"),
+            operand_symbols(operation, 0)?,
+        ))
+    }
+
+    pub(crate) fn op(symbol: String, formula: String, operands: Vec<String>) -> Self {
+        Self {
+            symbol,
+            kind: "op".to_owned(),
+            formula,
+            operand_names: operands.clone(),
+            operands,
+        }
+    }
+}
+
+impl FieldExprDependencies for CpuFieldExprPlan {
+    fn symbol(&self) -> &str {
+        &self.symbol
+    }
+
+    fn operands(&self) -> &[String] {
+        &self.operands
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CpuScalarExprPlan {
+    pub symbol: String,
+    pub kind: String,
+    pub formula: String,
+    pub operand_names: Vec<String>,
+    pub operands: Vec<String>,
+}
+
+impl CpuScalarExprPlan {
+    pub(crate) fn op(symbol: String, formula: String, operands: Vec<String>) -> Self {
+        Self {
+            symbol,
+            kind: "op".to_owned(),
+            formula,
+            operand_names: operands.clone(),
+            operands,
+        }
+    }
+}
diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs
new file mode 100644
index 0000000000..34cda20833
--- /dev/null
+++ b/crates/bolt/src/protocols/jolt/verifier_values.rs
@@ -0,0 +1,331 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use crate::emit::rust::EmitError;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum VerifierScalarSourceKind {
+    OpeningInput,
+    FieldConstant,
+    TranscriptScalar,
+    FieldExpr,
+    ScalarExpr,
+    StructuredPolynomialEval,
+    RelationOutputLocal,
+    SumcheckEval,
+    OutputEvalFamily,
+    OutputProductFamily,
+    OutputFunctionFamily,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum VerifierScalarValueKind {
+    OpeningInput,
+    FieldConstant,
+    TranscriptScalar,
+    FieldExpr,
+    ScalarExpr,
+    StructuredPolynomialEval,
+    RelationOutputLocal,
+    SumcheckEval,
+    OutputEvalFamily,
+    OutputProductFamily,
+    OutputFunctionFamily,
+}
+
+impl VerifierScalarValueKind {
+    fn source_kind(self) -> VerifierScalarSourceKind {
+        match self {
+            Self::OpeningInput => VerifierScalarSourceKind::OpeningInput,
+            Self::FieldConstant => VerifierScalarSourceKind::FieldConstant,
+            Self::TranscriptScalar => VerifierScalarSourceKind::TranscriptScalar,
+            Self::FieldExpr => VerifierScalarSourceKind::FieldExpr,
+            Self::ScalarExpr => VerifierScalarSourceKind::ScalarExpr,
+            Self::StructuredPolynomialEval => VerifierScalarSourceKind::StructuredPolynomialEval,
+            Self::RelationOutputLocal => VerifierScalarSourceKind::RelationOutputLocal,
+            Self::SumcheckEval => VerifierScalarSourceKind::SumcheckEval,
+            Self::OutputEvalFamily => VerifierScalarSourceKind::OutputEvalFamily,
+            Self::OutputProductFamily => VerifierScalarSourceKind::OutputProductFamily,
+            Self::OutputFunctionFamily => VerifierScalarSourceKind::OutputFunctionFamily,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct VerifierScalarValuePlan {
+    pub(crate) symbol: String,
+    pub(crate) kind: VerifierScalarValueKind,
+}
+
+impl VerifierScalarValuePlan {
+    pub(crate) fn new(symbol: impl Into<String>, kind: VerifierScalarValueKind) -> Self {
+        Self {
+            symbol: symbol.into(),
+            kind,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VerifierScalarValueRef {
+    symbol: String,
+}
+
+impl VerifierScalarValueRef {
+    pub fn new(symbol: impl Into<String>) -> Self {
+        Self {
+            symbol: symbol.into(),
+        }
+    }
+
+    pub fn symbol(&self) -> &str {
+        &self.symbol
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub(crate) struct VerifierScalarValueSet {
+    symbols: BTreeMap<String, VerifierScalarValueKind>,
+    conflicts: Vec<VerifierSourceConflict<VerifierScalarValueKind>>,
+}
+
+impl VerifierScalarValueSet {
+    pub(crate) fn insert(&mut self, symbol: &str, kind: VerifierScalarValueKind) {
+        match self.symbols.entry(symbol.to_owned()) {
+            std::collections::btree_map::Entry::Vacant(entry) => {
+                let _entry = entry.insert(kind);
+            }
+            std::collections::btree_map::Entry::Occupied(entry) => {
+                let existing = *entry.get();
+                if existing != kind {
+                    self.conflicts.push(VerifierSourceConflict {
+                        symbol: symbol.to_owned(),
+                        existing,
+                        incoming: kind,
+                    });
+                }
+            }
+        }
+    }
+
+    pub(crate) fn insert_plan(&mut self, plan: &VerifierScalarValuePlan) {
+        self.insert(&plan.symbol, plan.kind);
+    }
+
+    pub(crate) fn extend_plans<'a>(
+        &mut self,
+        plans: impl IntoIterator<Item = &'a VerifierScalarValuePlan>,
+    ) {
+        for plan in plans {
+            self.insert_plan(plan);
+        }
+    }
+
+    pub(crate) fn contains_ref(&self, value_ref: &VerifierScalarValueRef) -> bool {
+        self.symbols.contains_key(value_ref.symbol())
+    }
+
+    pub(crate) fn contains_plan(&self, plan: &VerifierScalarValuePlan) -> bool {
+        self.symbols
+            .get(&plan.symbol)
+            .is_some_and(|kind| *kind == plan.kind)
+    }
+
+    pub(crate) fn source_set(&self) -> VerifierScalarSourceSet {
+        let mut sources = VerifierScalarSourceSet::default();
+        for (symbol, kind) in &self.symbols {
+            sources.insert(symbol, kind.source_kind());
+        }
+        sources
+    }
+
+    pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> {
+        let Some(conflict) = self.conflicts.first() else {
+            return Ok(());
+        };
+        Err(conflicting_source_error(stage, "scalar value", conflict))
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct VerifierScalarSourceSet {
+    symbols: BTreeMap<String, VerifierScalarSourceKind>,
+}
+
+impl VerifierScalarSourceSet {
+    pub fn insert(&mut self, symbol: &str, kind: VerifierScalarSourceKind) {
+        let _entry = self.symbols.entry(symbol.to_owned()).or_insert(kind);
+    }
+
+    pub fn extend<'a>(
+        &mut self,
+        symbols: impl IntoIterator<Item = &'a String>,
+        kind: VerifierScalarSourceKind,
+    ) {
+        for symbol in symbols {
+            self.insert(symbol, kind);
+        }
+    }
+
+    pub fn contains(&self, symbol: &str) -> bool {
+        self.symbols.contains_key(symbol)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum VerifierFieldVectorValueKind {
+    IndexedEvalFamily,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VerifierFieldVectorValueRef {
+    symbol: String,
+}
+
+impl VerifierFieldVectorValueRef {
+    pub fn new(symbol: impl Into<String>) -> Self {
+        Self {
+            symbol: symbol.into(),
+        }
+    }
+
+    pub fn symbol(&self) -> &str {
+        &self.symbol
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub(crate) struct VerifierFieldVectorValueSet {
+    symbols: BTreeSet<String>,
+}
+
+impl VerifierFieldVectorValueSet {
+    pub(crate) fn insert(&mut self, symbol: &str, _kind: VerifierFieldVectorValueKind) {
+        let _inserted = self.symbols.insert(symbol.to_owned());
+    }
+
+    pub(crate) fn contains_ref(&self, value_ref: &VerifierFieldVectorValueRef) -> bool {
+        self.symbols.contains(value_ref.symbol())
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum VerifierPointSourceKind {
+    OpeningInput,
+    SumcheckInstance,
+    PointExpr,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum VerifierPointValueKind {
+    OpeningInput,
+    SumcheckInstance,
+    PointExpr,
+}
+
+impl VerifierPointValueKind {
+    fn source_kind(self) -> VerifierPointSourceKind {
+        match self {
+            Self::OpeningInput => VerifierPointSourceKind::OpeningInput,
+            Self::SumcheckInstance => VerifierPointSourceKind::SumcheckInstance,
+            Self::PointExpr => VerifierPointSourceKind::PointExpr,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VerifierPointValueRef {
+    symbol: String,
+}
+
+impl VerifierPointValueRef {
+    pub fn new(symbol: impl Into<String>) -> Self {
+        Self {
+            symbol: symbol.into(),
+        }
+    }
+
+    pub fn symbol(&self) -> &str {
+        &self.symbol
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub(crate) struct VerifierPointValueSet {
+    symbols: BTreeMap<String, VerifierPointValueKind>,
+    conflicts: Vec<VerifierSourceConflict<VerifierPointValueKind>>,
+}
+
+impl VerifierPointValueSet {
+    pub(crate) fn insert(&mut self, symbol: &str, kind: VerifierPointValueKind) {
+        match self.symbols.entry(symbol.to_owned()) {
+            std::collections::btree_map::Entry::Vacant(entry) => {
+                let _entry = entry.insert(kind);
+            }
+            std::collections::btree_map::Entry::Occupied(entry) => {
+                let existing = *entry.get();
+                if existing != kind {
+                    self.conflicts.push(VerifierSourceConflict {
+                        symbol: symbol.to_owned(),
+                        existing,
+                        incoming: kind,
+                    });
+                }
+            }
+        }
+    }
+
+    pub(crate) fn contains_ref(&self, value_ref: &VerifierPointValueRef) -> bool {
+        self.symbols.contains_key(value_ref.symbol())
+    }
+
+    pub(crate) fn source_set(&self) -> VerifierPointSourceSet {
+        let mut sources = VerifierPointSourceSet::default();
+        for (symbol, kind) in &self.symbols {
+            sources.insert(symbol, kind.source_kind());
+        }
+        sources
+    }
+
+    pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> {
+        let Some(conflict) = self.conflicts.first() else {
+            return Ok(());
+        };
+        Err(conflicting_source_error(stage, "point value", conflict))
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct VerifierPointSourceSet {
+    symbols: BTreeMap<String, VerifierPointSourceKind>,
+}
+
+impl VerifierPointSourceSet {
+    pub fn insert(&mut self, symbol: &str, kind: VerifierPointSourceKind) {
+        let _entry = self.symbols.entry(symbol.to_owned()).or_insert(kind);
+    }
+
+    pub fn contains(&self, symbol: &str) -> bool {
+        self.symbols.contains_key(symbol)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct VerifierSourceConflict<K> {
+    symbol: String,
+    existing: K,
+    incoming: K,
+}
+
+fn conflicting_source_error<K>(
+    stage: &str,
+    value_kind: &str,
+    conflict: &VerifierSourceConflict<K>,
+) -> EmitError
+where
+    K: std::fmt::Debug,
+{
+    EmitError::new(format!(
+        "{stage} {value_kind} source @{} has conflicting kinds {:?} and {:?}",
+        conflict.symbol, conflict.existing, conflict.incoming
+    ))
+}
diff --git a/crates/bolt/src/schema.rs b/crates/bolt/src/schema.rs
index 46e963c4e7..710a3fc3ce 100644
--- a/crates/bolt/src/schema.rs
+++ b/crates/bolt/src/schema.rs
@@ -14,6 +14,48 @@ use crate::ir::{
 use crate::mlir::MlirError;
 use crate::pass::{verify_concrete_transcript, VerifyError};
 
+const STRUCTURED_POLYNOMIAL_EVAL_ATTRS: &[&str] = &[
+    "sym_name",
+    "polynomial",
+    "x_point_segment",
+    "x_point_length",
+    "x_point_order",
+    "y_point_segment",
+    "y_point_length",
+    "y_point_order",
+];
+
+const SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS: &[&str] = &[
+    "sym_name",
+    "power_stride",
+    "value_term_offsets",
+    "shared_term_offsets",
+    "item_term_offsets",
+    "evals",
+    "shared_terms",
+    "item_terms",
+];
+
+const SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS: &[&str] = &[
+    "sym_name",
+    "gamma",
+    "term_gamma_power_offsets",
+    "term_eval_counts",
+    "term_factor_counts",
+    "evals",
+    "factors",
+];
+
+const SUMCHECK_OUTPUT_FUNCTION_FAMILY_ATTRS: &[&str] = &[
+    "sym_name",
+    "gamma",
+    "term_gamma_power_offsets",
+    "term_functions",
+    "term_factor_counts",
+    "evals",
+    "factors",
+];
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SchemaError {
     message: String,
@@ -344,6 +386,14 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<(
             )?;
             require_shape(operation, 1, 1)
         }
+        "piop.sumcheck_eval_family" => {
+            require_attrs(
+                operation,
+                &["sym_name", "source", "oracle_family", "count", "evals"],
+            )?;
+            require_shape(operation, 0, 0)?;
+            require_counted_symbols(operation, "evals")
+        }
         "piop.sumcheck_instance_result" => {
             require_attrs(
                 operation,
@@ -362,6 +412,34 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<(
             )?;
             require_shape(operation, 2, 2)
         }
+        "piop.structured_polynomial_eval" => {
+            require_attrs(operation, STRUCTURED_POLYNOMIAL_EVAL_ATTRS)?;
+            require_shape(operation, 2, 1)?;
+            require_structured_polynomial_eval(operation)
+        }
+        "piop.sumcheck_output_eval_family" => {
+            require_attrs(operation, SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS)?;
+            require_min_shape(operation, 1, 1)?;
+            require_sumcheck_output_eval_family(operation)
+        }
+        "piop.sumcheck_output_product_family" => {
+            require_attrs(operation, SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS)?;
+            require_min_shape(operation, 1, 1)?;
+            require_sumcheck_output_product_family(operation)
+        }
+        "piop.sumcheck_output_function_family" => {
+            require_attrs(operation, SUMCHECK_OUTPUT_FUNCTION_FAMILY_ATTRS)?;
+            require_min_shape(operation, 1, 1)?;
+            require_sumcheck_output_function_family(operation)
+        }
+        "piop.sumcheck_output_claim" => {
+            require_attrs(
+                operation,
+                &["sym_name", "stage", "relation", "count", "polynomial_evals"],
+            )?;
+            require_min_shape(operation, 1, 0)?;
+            require_sumcheck_output_claim(operation)
+        }
         "piop.opening_claim" => {
             require_attrs(
                 operation,
@@ -688,6 +766,14 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<(
             )?;
             require_shape(operation, 1, 1)
         }
+        "compute.sumcheck_eval_family" => {
+            require_attrs(
+                operation,
+                &["sym_name", "source", "oracle_family", "count", "evals"],
+            )?;
+            require_shape(operation, 0, 0)?;
+            require_counted_symbols(operation, "evals")
+        }
         "compute.sumcheck_instance_result" => {
             require_attrs(
                 operation,
@@ -706,6 +792,34 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<(
             )?;
             require_shape(operation, 2, 2)
         }
+        "compute.structured_polynomial_eval" => {
+            require_attrs(operation, STRUCTURED_POLYNOMIAL_EVAL_ATTRS)?;
+            require_shape(operation, 2, 1)?;
+            require_structured_polynomial_eval(operation)
+        }
+        "compute.sumcheck_output_eval_family" => {
+            require_attrs(operation, SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS)?;
+            require_min_shape(operation, 1, 1)?;
+            require_sumcheck_output_eval_family(operation)
+        }
+        "compute.sumcheck_output_product_family" => {
+            require_attrs(operation, SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS)?;
+            require_min_shape(operation, 1, 1)?;
+            require_sumcheck_output_product_family(operation)
+        }
+        "compute.sumcheck_output_function_family" => {
+            require_attrs(operation, SUMCHECK_OUTPUT_FUNCTION_FAMILY_ATTRS)?;
+            require_min_shape(operation, 1, 1)?;
+            require_sumcheck_output_function_family(operation)
+        }
+        "compute.sumcheck_output_claim" => {
+            require_attrs(
+                operation,
+                &["sym_name", "stage", "relation", "count", "polynomial_evals"],
+            )?;
+            require_min_shape(operation, 1, 0)?;
+            require_sumcheck_output_claim(operation)
+        }
         "compute.opening_claim" => {
             require_attrs(
                 operation,
@@ -1015,6 +1129,14 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<(
             )?;
             require_shape(operation, 1, 1)
         }
+        "cpu.sumcheck_eval_family" => {
+            require_attrs(
+                operation,
+                &["sym_name", "source", "oracle_family", "count", "evals"],
+            )?;
+            require_shape(operation, 0, 0)?;
+            require_counted_symbols(operation, "evals")
+        }
         "cpu.sumcheck_instance_result" => {
             require_attrs(
                 operation,
@@ -1033,6 +1155,34 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<(
             )?;
             require_shape(operation, 2, 2)
         }
+        "cpu.structured_polynomial_eval" => {
+            require_attrs(operation, STRUCTURED_POLYNOMIAL_EVAL_ATTRS)?;
+            require_shape(operation, 2, 1)?;
+            require_structured_polynomial_eval(operation)
+        }
+        "cpu.sumcheck_output_eval_family" => {
+            require_attrs(operation, SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS)?;
+            require_min_shape(operation, 1, 1)?;
+            require_sumcheck_output_eval_family(operation)
+        }
+        "cpu.sumcheck_output_product_family" => {
+            require_attrs(operation, SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS)?;
+            require_min_shape(operation, 1, 1)?;
+            require_sumcheck_output_product_family(operation)
+        }
+        "cpu.sumcheck_output_function_family" => {
+            require_attrs(operation, SUMCHECK_OUTPUT_FUNCTION_FAMILY_ATTRS)?;
+            require_min_shape(operation, 1, 1)?;
+            require_sumcheck_output_function_family(operation)
+        }
+        "cpu.sumcheck_output_claim" => {
+            require_attrs(
+                operation,
+                &["sym_name", "stage", "relation", "count", "polynomial_evals"],
+            )?;
+            require_min_shape(operation, 1, 0)?;
+            require_sumcheck_output_claim(operation)
+        }
         "cpu.opening_claim" => {
             require_attrs(
                 operation,
@@ -1158,6 +1308,293 @@ fn require_opening_claim_equality(operation: OperationRef<'_, '_>) -> Result<(),
     Ok(())
 }
 
+fn require_structured_polynomial_eval(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> {
+    let polynomial = string_attr(operation, "polynomial")?;
+    if !matches!(polynomial.as_str(), "eq" | "eq_plus_one" | "lt") {
+        return Err(SchemaError::new(format!(
+            "{} attr `polynomial` has unsupported structured polynomial `{polynomial}`",
+            operation_name(operation)
+        )));
+    }
+    require_structured_polynomial_point_attrs(operation, "x_point")?;
+    require_structured_polynomial_point_attrs(operation, "y_point")?;
+    Ok(())
+}
+
+fn require_structured_polynomial_point_attrs(
+    operation: OperationRef<'_, '_>,
+    prefix: &str,
+) -> Result<(), SchemaError> {
+    let segment_attr = format!("{prefix}_segment");
+    let segment = string_attr(operation, &segment_attr)?;
+    if !matches!(segment.as_str(), "full" | "prefix" | "suffix") {
+        return Err(SchemaError::new(format!(
+            "{} attr `{segment_attr}` has unsupported output point segment `{segment}`",
+            operation_name(operation)
+        )));
+    }
+    let length_attr = format!("{prefix}_length");
+    let length = string_attr(operation, &length_attr)?;
+    if !matches!(length.as_str(), "full" | "x_point" | "y_point") {
+        return Err(SchemaError::new(format!(
+            "{} attr `{length_attr}` has unsupported output point length `{length}`",
+            operation_name(operation)
+        )));
+    }
+    if segment == "full" && length != "full" {
+        return Err(SchemaError::new(format!(
+            "{} output point `{prefix}` uses segment `full` but length `{length}`; full segments must use length `full`",
+            operation_name(operation)
+        )));
+    }
+    let order_attr = format!("{prefix}_order");
+    let order = string_attr(operation, &order_attr)?;
+    if !matches!(order.as_str(), "as_is" | "reverse") {
+        return Err(SchemaError::new(format!(
+            "{} attr `{order_attr}` has unsupported output point order `{order}`",
+            operation_name(operation)
+        )));
+    }
+    Ok(())
+}
+
+fn require_sumcheck_output_eval_family(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> {
+    let evals = symbol_array_attr(operation, "evals")?;
+    let shared_terms = symbol_array_attr(operation, "shared_terms")?;
+    let item_terms = symbol_array_attr(operation, "item_terms")?;
+    let shared_offsets = int_array_attr(operation, "shared_term_offsets")?;
+    let item_offsets = int_array_attr(operation, "item_term_offsets")?;
+    if shared_terms.len() != shared_offsets.len() {
+        return Err(SchemaError::new(format!(
+            "{} attr `shared_terms` length {} does not match shared_term_offsets length {}",
+            operation_name(operation),
+            shared_terms.len(),
+            shared_offsets.len()
+        )));
+    }
+    let expected_item_terms = item_offsets.len() * evals.len();
+    if item_terms.len() != expected_item_terms {
+        return Err(SchemaError::new(format!(
+            "{} attr `item_terms` length {} does not match item_term_offsets length {} times evals length {}",
+            operation_name(operation),
+            item_terms.len(),
+            item_offsets.len(),
+            evals.len()
+        )));
+    }
+    let expected_operands = 1 + evals.len() + shared_terms.len() + item_terms.len();
+    if operation.operand_count() != expected_operands {
+        return Err(SchemaError::new(format!(
+            "{} expected {expected_operands} operands, got {}",
+            operation_name(operation),
+            operation.operand_count()
+        )));
+    }
+    let expected_symbols = evals
+        .iter()
+        .chain(shared_terms.iter())
+        .chain(item_terms.iter())
+        .collect::<Vec<_>>();
+    for (index, expected) in expected_symbols.iter().enumerate() {
+        let operand_index = index + 1;
+        let actual = operand_owner_symbol(operation, operand_index)?;
+        if &actual != *expected {
+            return Err(SchemaError::new(format!(
+                "{} operand {operand_index} expected @{expected}, got @{actual}",
+                operation_name(operation)
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn require_sumcheck_output_product_family(
+    operation: OperationRef<'_, '_>,
+) -> Result<(), SchemaError> {
+    let gamma = optional_symbol_array_attr(operation, "gamma")?;
+    let evals = symbol_array_attr(operation, "evals")?;
+    let factors = symbol_array_attr(operation, "factors")?;
+    let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?;
+    let term_eval_counts = int_array_attr(operation, "term_eval_counts")?;
+    let term_factor_counts = int_array_attr(operation, "term_factor_counts")?;
+    if term_eval_counts.len() != term_gamma_power_offsets.len() {
+        return Err(SchemaError::new(format!(
+            "{} attr `term_eval_counts` length {} does not match term_gamma_power_offsets length {}",
+            operation_name(operation),
+            term_eval_counts.len(),
+            term_gamma_power_offsets.len()
+        )));
+    }
+    if term_factor_counts.len() != term_gamma_power_offsets.len() {
+        return Err(SchemaError::new(format!(
+            "{} attr `term_factor_counts` length {} does not match term_gamma_power_offsets length {}",
+            operation_name(operation),
+            term_factor_counts.len(),
+            term_gamma_power_offsets.len()
+        )));
+    }
+    for ((index, eval_count), factor_count) in term_eval_counts
+        .iter()
+        .enumerate()
+        .zip(term_factor_counts.iter())
+    {
+        if *eval_count == 0 && *factor_count == 0 {
+            return Err(SchemaError::new(format!(
+                "{} product-family term {index} is empty",
+                operation_name(operation)
+            )));
+        }
+    }
+    let expected_evals: usize = term_eval_counts.iter().sum();
+    if evals.len() != expected_evals {
+        return Err(SchemaError::new(format!(
+            "{} attr `evals` length {} does not match sum(term_eval_counts) {}",
+            operation_name(operation),
+            evals.len(),
+            expected_evals
+        )));
+    }
+    let expected_factors: usize = term_factor_counts.iter().sum();
+    if factors.len() != expected_factors {
+        return Err(SchemaError::new(format!(
+            "{} attr `factors` length {} does not match sum(term_factor_counts) {}",
+            operation_name(operation),
+            factors.len(),
+            expected_factors
+        )));
+    }
+    let expected_operands = gamma.len() + evals.len() + factors.len();
+    if operation.operand_count() != expected_operands {
+        return Err(SchemaError::new(format!(
+            "{} expected {expected_operands} operands, got {}",
+            operation_name(operation),
+            operation.operand_count()
+        )));
+    }
+    let expected_symbols = gamma
+        .iter()
+        .chain(evals.iter())
+        .chain(factors.iter())
+        .collect::<Vec<_>>();
+    for (index, expected) in expected_symbols.iter().enumerate() {
+        let operand_index = index;
+        let actual = operand_owner_symbol(operation, operand_index)?;
+        if &actual != *expected {
+            return Err(SchemaError::new(format!(
+                "{} operand {operand_index} expected @{expected}, got @{actual}",
+                operation_name(operation)
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn require_sumcheck_output_function_family(
+    operation: OperationRef<'_, '_>,
+) -> Result<(), SchemaError> {
+    let gamma = optional_symbol_array_attr(operation, "gamma")?;
+    let evals = symbol_array_attr(operation, "evals")?;
+    let factors = symbol_array_attr(operation, "factors")?;
+    let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?;
+    let term_functions = string_array_attr(operation, "term_functions")?;
+    let term_factor_counts = int_array_attr(operation, "term_factor_counts")?;
+    if term_functions.len() != term_gamma_power_offsets.len() {
+        return Err(SchemaError::new(format!(
+            "{} attr `term_functions` length {} does not match term_gamma_power_offsets length {}",
+            operation_name(operation),
+            term_functions.len(),
+            term_gamma_power_offsets.len()
+        )));
+    }
+    if term_factor_counts.len() != term_gamma_power_offsets.len() {
+        return Err(SchemaError::new(format!(
+            "{} attr `term_factor_counts` length {} does not match term_gamma_power_offsets length {}",
+            operation_name(operation),
+            term_factor_counts.len(),
+            term_gamma_power_offsets.len()
+        )));
+    }
+    for (index, function) in term_functions.iter().enumerate() {
+        if function != "boolean_zero" {
+            return Err(SchemaError::new(format!(
+                "{} function-family term {index} has unsupported function `{function}`",
+                operation_name(operation)
+            )));
+        }
+    }
+    if evals.len() != term_gamma_power_offsets.len() {
+        return Err(SchemaError::new(format!(
+            "{} attr `evals` length {} does not match term count {}",
+            operation_name(operation),
+            evals.len(),
+            term_gamma_power_offsets.len()
+        )));
+    }
+    let expected_factors: usize = term_factor_counts.iter().sum();
+    if factors.len() != expected_factors {
+        return Err(SchemaError::new(format!(
+            "{} attr `factors` length {} does not match sum(term_factor_counts) {}",
+            operation_name(operation),
+            factors.len(),
+            expected_factors
+        )));
+    }
+    let expected_operands = gamma.len() + evals.len() + factors.len();
+    if operation.operand_count() != expected_operands {
+        return Err(SchemaError::new(format!(
+            "{} expected {expected_operands} operands, got {}",
+            operation_name(operation),
+            operation.operand_count()
+        )));
+    }
+    let expected_symbols = gamma
+        .iter()
+        .chain(evals.iter())
+        .chain(factors.iter())
+        .collect::<Vec<_>>();
+    for (index, expected) in expected_symbols.iter().enumerate() {
+        let operand_index = index;
+        let actual = operand_owner_symbol(operation, operand_index)?;
+        if &actual != *expected {
+            return Err(SchemaError::new(format!(
+                "{} operand {operand_index} expected @{expected}, got @{actual}",
+                operation_name(operation)
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn require_sumcheck_output_claim(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> {
+    let count = int_attr(operation, "count")?;
+    let polynomial_evals = symbol_array_attr(operation, "polynomial_evals")?;
+    if polynomial_evals.len() != count {
+        return Err(SchemaError::new(format!(
+            "{} attr `polynomial_evals` length {} does not match count {count}",
+            operation_name(operation),
+            polynomial_evals.len()
+        )));
+    }
+    let dynamic_count = operation.operand_count().saturating_sub(1);
+    if dynamic_count != count {
+        return Err(SchemaError::new(format!(
+            "{} attr `count` expected {dynamic_count}, got {count}",
+            operation_name(operation)
+        )));
+    }
+    for (index, expected) in polynomial_evals.iter().enumerate() {
+        let operand_index = index + 1;
+        let actual = operand_owner_symbol(operation, operand_index)?;
+        if &actual != expected {
+            return Err(SchemaError::new(format!(
+                "{} operand {operand_index} expected @{expected}, got @{actual}",
+                operation_name(operation)
+            )));
+        }
+    }
+    Ok(())
+}
+
 fn opening_claim_metadata(
     equality_op: OperationRef<'_, '_>,
     operand_index: usize,
@@ -1280,6 +1717,28 @@ fn require_counted_operands(
     Ok(())
 }
 
+fn require_counted_symbols(
+    operation: OperationRef<'_, '_>,
+    ordered_attr: &str,
+) -> Result<(), SchemaError> {
+    let count = int_attr(operation, "count")?;
+    let ordered = symbol_array_attr(operation, ordered_attr)?;
+    if count == 0 {
+        return Err(SchemaError::new(format!(
+            "{} attr `{ordered_attr}` must contain at least one symbol",
+            operation_name(operation)
+        )));
+    }
+    if ordered.len() != count {
+        return Err(SchemaError::new(format!(
+            "{} attr `{ordered_attr}` length {} does not match count {count}",
+            operation_name(operation),
+            ordered.len()
+        )));
+    }
+    Ok(())
+}
+
 pub(crate) fn require_attrs(
     operation: OperationRef<'_, '_>,
     attrs: &[&str],
@@ -1394,6 +1853,22 @@ pub(crate) fn symbol_array_attr(
     parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array"))
 }
 
+fn optional_symbol_array_attr(
+    operation: OperationRef<'_, '_>,
+    attr: &str,
+) -> Result<Vec<String>, SchemaError> {
+    let values = symbol_array_attr(operation, attr)?;
+    if values.len() <= 1 {
+        Ok(values)
+    } else {
+        Err(SchemaError::new(format!(
+            "{} attr `{attr}` expected zero or one symbols, got {}",
+            operation_name(operation),
+            values.len()
+        )))
+    }
+}
+
 fn parse_symbol_array(attribute: &str) -> Option<Vec<String>> {
     let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
     if inner.is_empty() {
@@ -1405,6 +1880,54 @@ fn parse_symbol_array(attribute: &str) -> Option<Vec<String>> {
         .collect()
 }
 
+fn string_array_attr(
+    operation: OperationRef<'_, '_>,
+    attr: &str,
+) -> Result<Vec<String>, SchemaError> {
+    let attribute = operation
+        .attribute(attr)
+        .map(|attribute| attribute.to_string())
+        .ok()
+        .ok_or_else(|| attr_error(operation, attr, "string array"))?;
+    parse_string_array(&attribute).ok_or_else(|| attr_error(operation, attr, "string array"))
+}
+
+fn parse_string_array(attribute: &str) -> Option<Vec<String>> {
+    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
+    if inner.is_empty() {
+        return Some(Vec::new());
+    }
+    inner
+        .split(',')
+        .map(|item| {
+            item.trim()
+                .strip_prefix('"')?
+                .strip_suffix('"')
+                .map(ToOwned::to_owned)
+        })
+        .collect()
+}
+
+fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<Vec<usize>, SchemaError> {
+    let attribute = operation
+        .attribute(attr)
+        .map(|attribute| attribute.to_string())
+        .ok()
+        .ok_or_else(|| attr_error(operation, attr, "integer array"))?;
+    parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array"))
+}
+
+fn parse_int_array(attribute: &str) -> Option<Vec<usize>> {
+    let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim();
+    if inner.is_empty() {
+        return Some(Vec::new());
+    }
+    inner
+        .split(',')
+        .map(|item| item.trim().parse().ok())
+        .collect()
+}
+
 pub(crate) fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result<usize, SchemaError> {
     operation
         .attribute(attr)
diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs
index 88c2f987de..a230ddd9fd 100644
--- a/crates/bolt/tests/commitment_ir.rs
+++ b/crates/bolt/tests/commitment_ir.rs
@@ -328,6 +328,35 @@ fn protocol_schema_accepts_explicit_sumcheck_and_opening_flow() {
     assert!(text.contains("\"pcs.batch_open\"(%"));
 }
 
+#[test]
+fn protocol_schema_rejects_eval_family_count_mismatch() {
+    let context = MeliorContext::new();
+    let protocol = context
+        .parse_module::<bolt::Protocol>(&explicit_sumcheck_protocol_with_eval_family(
+            2,
+            "[@stage1.outer.eval]",
+        ))
+        .expect("parse protocol with mismatched eval family");
+
+    let error = verify_protocol_schema(&protocol).expect_err("eval family count mismatch");
+    assert!(error
+        .to_string()
+        .contains("piop.sumcheck_eval_family attr `evals` length 1 does not match count 2"));
+}
+
+#[test]
+fn protocol_schema_rejects_empty_eval_family() {
+    let context = MeliorContext::new();
+    let protocol = context
+        .parse_module::<bolt::Protocol>(&explicit_sumcheck_protocol_with_eval_family(0, "[]"))
+        .expect("parse protocol with empty eval family");
+
+    let error = verify_protocol_schema(&protocol).expect_err("empty eval family rejected");
+    assert!(error
+        .to_string()
+        .contains("piop.sumcheck_eval_family attr `evals` must contain at least one symbol"));
+}
+
 #[test]
 fn opening_batch_schema_rejects_hidden_or_reordered_claims() {
     let context = MeliorContext::new();
@@ -816,6 +845,12 @@ fn jolt_stage5_protocol_defines_value_lookup_reduction_flow() {
     assert!(text.contains("@stage5.ram_ra_claim_reduction.opening.RamRa"));
     assert!(text.contains("@stage5.registers_val_evaluation.opening.RdInc"));
     assert!(text.contains("@stage5.registers_val_evaluation.opening.RdWa"));
+    assert!(text.contains("sym_name = \"stage5.ram_ra_claim_reduction.output.eq.Raf\""));
+    assert!(text.contains("sym_name = \"stage5.ram_ra_claim_reduction.output.claim\""));
+    assert!(
+        text.contains("sym_name = \"stage5.registers_val_evaluation.output.lt.RegistersValCycle\"")
+    );
+    assert!(text.contains("sym_name = \"stage5.registers_val_evaluation.output.claim\""));
     assert!(!text.contains("kernel = @"));
     assert!(!text.contains("\"compute."));
 }
@@ -868,6 +903,8 @@ fn jolt_stage5_lowers_to_compute_and_cpu_role_ir() {
     assert!(prover_kernel_text.contains("kernel = @jolt.cpu.stage5.batched"));
     assert!(prover_cpu_text.contains("kernel = @jolt.cpu.stage5.batched"));
     assert!(prover_cpu_text.contains("point_order = \"instruction_read_raf\""));
+    assert!(verifier_cpu_text.contains("\"cpu.structured_polynomial_eval\""));
+    assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_claim\""));
     assert!(verifier_cpu_text.contains("\"cpu.sumcheck_verify_claim\""));
     assert!(!verifier_kernel_text.contains("kernel = @"));
     assert!(!verifier_cpu_text.contains("kernel = @"));
@@ -895,7 +932,6 @@ fn jolt_stage6_protocol_defines_bytecode_booleanity_and_virtualization_flow() {
     assert!(text.contains("sym_name = \"stage6.booleanity.gamma\""));
     assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.gamma\""));
     assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.gamma\""));
-    assert!(text.contains("sym_name = \"stage6.booleanity.gamma_sq_0\""));
     assert!(text.contains("source_claim = @stage2.ram_read_write.opening.RamInc"));
     assert!(text.contains("source_claim = @stage4.registers_read_write.opening.RdInc"));
     assert!(text.contains("source_claim = @stage5.registers_val_evaluation.opening.RdInc"));
@@ -908,6 +944,21 @@ fn jolt_stage6_protocol_defines_bytecode_booleanity_and_virtualization_flow() {
     assert!(text.contains("@stage6.instruction_ra_virtual.opening.InstructionRa_0"));
     assert!(text.contains("@stage6.inc_claim_reduction.opening.RamInc"));
     assert!(text.contains("@stage6.inc_claim_reduction.opening.RdInc"));
+    assert!(text.contains("sym_name = \"stage6.booleanity.output.claim\""));
+    assert!(text.contains("sym_name = \"stage6.hamming_booleanity.output.claim\""));
+    assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.claim\""));
+    assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.claim\""));
+    assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.claim\""));
+    assert!(text.contains("sym_name = \"stage6.booleanity.output.family\""));
+    assert!(text.contains("sym_name = \"stage6.hamming_booleanity.output.family\""));
+    assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.family\""));
+    assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.family\""));
+    assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.family\""));
+    assert!(text.contains("\"piop.sumcheck_output_function_family\""));
+    assert!(text.contains("\"piop.sumcheck_output_product_family\""));
+    assert!(text.contains("\"piop.sumcheck_output_eval_family\""));
+    assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.eq.RdIncStage5\""));
+    assert!(text.contains("sym_name = \"stage6.booleanity.output.eq.InstructionRa0\""));
     assert!(!text.contains("kernel = @"));
     assert!(!text.contains("\"compute."));
 }
@@ -961,6 +1012,9 @@ fn jolt_stage6_lowers_to_compute_and_cpu_role_ir() {
     assert!(prover_cpu_text.contains("kernel = @jolt.cpu.stage6.batched"));
     assert!(prover_cpu_text.contains("point_order = \"bytecode_read_raf\""));
     assert!(verifier_cpu_text.contains("\"cpu.sumcheck_verify_claim\""));
+    assert!(verifier_cpu_text.contains("\"cpu.structured_polynomial_eval\""));
+    assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_eval_family\""));
+    assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_claim\""));
     assert!(!verifier_kernel_text.contains("kernel = @"));
     assert!(!verifier_cpu_text.contains("kernel = @"));
 }
@@ -991,6 +1045,15 @@ fn jolt_stage7_protocol_defines_hamming_weight_claim_reduction_flow() {
     assert!(text.contains("source_claim = @stage6.hamming_booleanity.opening.HammingWeight"));
     assert!(text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.point.cycle\""));
     assert!(text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.point\""));
+    assert!(
+        text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.output.eq.Booleanity\"")
+    );
+    assert!(text.contains(
+        "sym_name = \"stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization\""
+    ));
+    assert!(text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.output.family\""));
+    assert!(text.contains("\"piop.sumcheck_output_eval_family\""));
+    assert!(text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.output\""));
     assert!(text.contains("@stage7.hamming_weight_claim_reduction.opening.InstructionRa_0"));
     assert!(text.contains("@stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0"));
     assert!(text.contains("@stage7.hamming_weight_claim_reduction.opening.RamRa_0"));
@@ -1047,6 +1110,9 @@ fn jolt_stage7_lowers_to_compute_and_cpu_role_ir() {
     assert!(prover_kernel_text.contains("kernel = @jolt.cpu.stage7.batched"));
     assert!(prover_cpu_text.contains("kernel = @jolt.cpu.stage7.batched"));
     assert!(prover_cpu_text.contains("point_order = \"reverse\""));
+    assert!(verifier_cpu_text.contains("\"cpu.structured_polynomial_eval\""));
+    assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_eval_family\""));
+    assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_claim\""));
     assert!(verifier_cpu_text.contains("\"cpu.sumcheck_verify_claim\""));
     assert!(!verifier_kernel_text.contains("kernel = @"));
     assert!(!verifier_cpu_text.contains("kernel = @"));
@@ -1229,7 +1295,7 @@ fn stage3_rust_targets_extract_and_compile() {
     assert!(verifier_source.source.contains("pub fn verify_stage3"));
     assert!(verifier_source
         .source
-        .contains("super::common::verify_batched_sumcheck"));
+        .contains("bolt_verifier_runtime::verify_batched_sumcheck"));
     assert!(verifier_source
         .source
         .contains("Stage3OpeningClaimEqualityPlan"));
@@ -1308,13 +1374,13 @@ fn stage4_rust_targets_extract_and_compile() {
         .contains("Stage4TranscriptAbsorbBytesPlan"));
     assert!(verifier_source
         .source
-        .contains("relation: Some(\"jolt.stage4.batched\")"));
+        .contains("relation: Some(Stage4RelationKind::Stage4Batched)"));
     assert!(verifier_source.source.contains("Stage4VerifierProgramPlan"));
     assert!(verifier_source.source.contains("pub fn verify_stage4"));
     assert!(verifier_source.source.contains("LabelWithCount"));
     assert!(verifier_source
         .source
-        .contains("super::common::verify_batched_sumcheck"));
+        .contains("bolt_verifier_runtime::verify_batched_sumcheck"));
     assert!(verifier_source.source.contains("stage4_verifier_program"));
     assert_or_update_fixture("tests/fixtures/prove_stage4.rs", &prover_source.source);
     assert_or_update_fixture("tests/fixtures/verify_stage4.rs", &verifier_source.source);
@@ -1349,6 +1415,10 @@ fn stage5_rust_targets_extract_and_compile() {
         prover_program.evals.len(),
         params.lookup_table_count + params.instruction_ra_virtual_d + 4
     );
+    assert_eq!(prover_program.relation_output_values.len(), 4);
+    assert!(prover_program.relation_outputs.is_empty());
+    assert_eq!(verifier_program.relation_output_values.len(), 5);
+    assert_eq!(verifier_program.relation_outputs.len(), 3);
     assert_eq!(
         prover_program.point_slices.len(),
         params.instruction_ra_virtual_d + 3
@@ -1394,31 +1464,44 @@ fn stage5_rust_targets_extract_and_compile() {
     assert!(verifier_source.source.contains("pub fn verify_stage5"));
     assert!(verifier_source
         .source
-        .contains("relation: Some(\"jolt.stage5.batched\")"));
+        .contains("relation: Some(Stage5RelationKind::Stage5Batched)"));
     assert!(verifier_source
         .source
-        .contains("expected_instruction_read_raf"));
+        .contains("evaluate_stage5_instruction_read_raf_local_scalars"));
     assert!(verifier_source
         .source
-        .contains("jolt.stage5.instruction_read_raf"));
+        .contains("Stage5RelationKind::Stage5InstructionReadRaf"));
     assert!(verifier_source
         .source
-        .contains("LookupTableKind::<XLEN>::all"));
+        .contains("JoltLocalScalarMleKind::LookupTable"));
+    assert!(!verifier_source
+        .source
+        .contains("expected_ram_ra_claim_reduction"));
+    assert!(!verifier_source
+        .source
+        .contains("expected_registers_val_evaluation"));
+    assert!(verifier_source.source.contains("Stage5RelationOutputPlan"));
     assert!(verifier_source
         .source
-        .contains("use jolt_lookup_tables::LookupTableKind"));
+        .contains("stage5.instruction_read_raf.output.claim_expr"));
     assert!(verifier_source
         .source
-        .contains("expected_ram_ra_claim_reduction"));
+        .contains("stage5.ram_ra_claim_reduction.output.eq.ReadWrite"));
     assert!(verifier_source
         .source
-        .contains("expected_registers_val_evaluation"));
+        .contains("stage5.registers_val_evaluation.output.lt.RegistersValCycle"));
     assert!(verifier_source
         .source
-        .contains("jolt.stage5.ram_ra_claim_reduction"));
+        .contains("bolt_verifier_runtime::evaluate_relation_output_batch"));
     assert!(verifier_source
         .source
-        .contains("jolt.stage5.registers_val_evaluation"));
+        .contains("stage5_relation_output_inputs"));
+    assert!(verifier_source
+        .source
+        .contains("Stage5RelationKind::Stage5RamRaClaimReduction"));
+    assert!(verifier_source
+        .source
+        .contains("Stage5RelationKind::Stage5RegistersValEvaluation"));
     assert!(verifier_source.source.contains("LookupTableFlag_40"));
     assert!(!verifier_source.source.contains("LookupTableFlag_41"));
     assert!(verifier_source
@@ -1433,7 +1516,7 @@ fn stage5_rust_targets_extract_and_compile() {
     assert!(!verifier_source.source.contains("jolt.stage5.ram_val_check"));
     assert!(verifier_source
         .source
-        .contains("super::common::verify_batched_sumcheck"));
+        .contains("bolt_verifier_runtime::verify_batched_sumcheck"));
     assert!(verifier_source.source.contains("stage5_verifier_program"));
     assert_rust_source_compiles(&prover_source.filename, &prover_source.source);
     assert_rust_source_compiles(&verifier_source.filename, &verifier_source.source);
@@ -1473,14 +1556,249 @@ fn stage6_rust_targets_extract_and_compile() {
             + params.instruction_d
             + 2
     );
+    assert_eq!(prover_program.relation_output_values.len(), 8);
+    assert!(prover_program.relation_outputs.is_empty());
+    assert_eq!(verifier_program.relation_output_values.len(), 8);
+    assert!(verifier_program.relation_output_eval_families.is_empty());
+    assert!(verifier_program.relation_output_product_families.is_empty());
+    assert!(verifier_program
+        .relation_output_function_families
+        .is_empty());
+    assert_eq!(verifier_program.relation_outputs.len(), 6);
+    let total_booleanity_ra = params.instruction_d + params.bytecode_d + params.ram_d;
+    let booleanity_exprs = verifier_program
+        .field_exprs
+        .iter()
+        .filter(|expr| expr.symbol.starts_with("stage6.booleanity.output."))
+        .collect::<Vec<_>>();
+    assert!(booleanity_exprs.iter().any(|expr| {
+        expr.symbol == "stage6.booleanity.output.term0.boolean_zero.square"
+            && expr.formula == "field.product"
+            && expr.operands
+                == vec![
+                    "stage6.booleanity.eval.InstructionRa_0".to_owned(),
+                    "stage6.booleanity.eval.InstructionRa_0".to_owned(),
+                ]
+    }));
+    assert!(booleanity_exprs.iter().any(|expr| {
+        expr.symbol == "stage6.booleanity.output.term0.boolean_zero"
+            && expr.formula == "field.sub"
+            && expr.operands
+                == vec![
+                    "stage6.booleanity.output.term0.boolean_zero.square".to_owned(),
+                    "stage6.booleanity.eval.InstructionRa_0".to_owned(),
+                ]
+    }));
+    assert!(booleanity_exprs.iter().any(|expr| {
+        expr.symbol == "stage6.booleanity.output.term0"
+            && expr.formula == "field.product"
+            && expr.operands
+                == vec![
+                    "stage6.booleanity.output.term0.boolean_zero".to_owned(),
+                    "stage6.booleanity.output.eq.InstructionRa0".to_owned(),
+                ]
+    }));
+    assert!(booleanity_exprs.iter().any(|expr| {
+        expr.symbol == "stage6.booleanity.output.gamma_pow_2"
+            && expr.formula == "field.pow:2"
+            && expr.operands == vec!["stage6.booleanity.gamma".to_owned()]
+    }));
+    assert!(booleanity_exprs.iter().any(|expr| {
+        expr.symbol
+            == format!(
+                "stage6.booleanity.output.gamma_pow_{}",
+                2 * (total_booleanity_ra - 1)
+            )
+    }));
+    assert!(booleanity_exprs.iter().any(|expr| {
+        expr.symbol == "stage6.booleanity.output.claim_expr" && expr.formula == "field.sum"
+    }));
+    let hamming_expr_symbols = verifier_program
+        .field_exprs
+        .iter()
+        .filter(|expr| expr.symbol.starts_with("stage6.hamming_booleanity.output."))
+        .map(|expr| expr.symbol.as_str())
+        .collect::<Vec<_>>();
+    assert_eq!(
+        hamming_expr_symbols,
+        vec![
+            "stage6.hamming_booleanity.output.term0.boolean_zero.square",
+            "stage6.hamming_booleanity.output.term0.boolean_zero",
+            "stage6.hamming_booleanity.output.term0",
+            "stage6.hamming_booleanity.output.claim_expr"
+        ]
+    );
+    assert!(verifier_program
+        .relation_output_product_families
+        .iter()
+        .all(|family| family.symbol != "stage6.ram_ra_virtual.output.family"));
+    assert!(verifier_program
+        .relation_output_product_families
+        .iter()
+        .all(|family| family.symbol != "stage6.instruction_ra_virtual.output.family"));
+    let ram_expr_symbols = verifier_program
+        .field_exprs
+        .iter()
+        .filter(|expr| expr.symbol.starts_with("stage6.ram_ra_virtual.output."))
+        .map(|expr| expr.symbol.as_str())
+        .collect::<Vec<_>>();
+    assert_eq!(
+        ram_expr_symbols,
+        vec![
+            "stage6.ram_ra_virtual.output.term0",
+            "stage6.ram_ra_virtual.output.claim_expr"
+        ]
+    );
+    let committed_per_virtual = params.instruction_d / params.instruction_ra_virtual_d;
+    let instruction_exprs = verifier_program
+        .field_exprs
+        .iter()
+        .filter(|expr| {
+            expr.symbol
+                .starts_with("stage6.instruction_ra_virtual.output.")
+        })
+        .collect::<Vec<_>>();
+    assert!(instruction_exprs
+        .iter()
+        .any(|expr| expr.symbol == "stage6.instruction_ra_virtual.output.claim_expr"));
+    assert!(instruction_exprs
+        .iter()
+        .any(|expr| expr.symbol == "stage6.instruction_ra_virtual.output.gamma_pow_7"));
+    for virtual_index in 0..params.instruction_ra_virtual_d {
+        let term = instruction_exprs
+            .iter()
+            .find(|expr| {
+                expr.symbol == format!("stage6.instruction_ra_virtual.output.term{virtual_index}")
+            })
+            .expect("instruction RA virtual output term");
+        if virtual_index == 0 {
+            assert!(!term
+                .operands
+                .contains(&"stage6.instruction_ra_virtual.output.gamma_pow_0".to_owned()));
+        } else {
+            assert!(term.operands.contains(&format!(
+                "stage6.instruction_ra_virtual.output.gamma_pow_{virtual_index}"
+            )));
+        }
+        assert_eq!(
+            term.operands
+                .iter()
+                .filter(|operand| operand.contains(".eval.InstructionRa_"))
+                .cloned()
+                .collect::<Vec<_>>(),
+            (0..committed_per_virtual)
+                .map(|chunk_index| {
+                    let index = virtual_index * committed_per_virtual + chunk_index;
+                    format!("stage6.instruction_ra_virtual.eval.InstructionRa_{index}")
+                })
+                .collect::<Vec<_>>()
+        );
+        assert!(term
+            .operands
+            .contains(&"stage6.instruction_ra_virtual.output.eq.Cycle".to_owned()));
+    }
+    let inc_expr_symbols = verifier_program
+        .field_exprs
+        .iter()
+        .filter(|expr| {
+            expr.symbol
+                .starts_with("stage6.inc_claim_reduction.output.")
+        })
+        .map(|expr| expr.symbol.as_str())
+        .collect::<Vec<_>>();
+    assert_eq!(
+        inc_expr_symbols,
+        vec![
+            "stage6.inc_claim_reduction.output.term0",
+            "stage6.inc_claim_reduction.output.gamma_pow_1",
+            "stage6.inc_claim_reduction.output.term1",
+            "stage6.inc_claim_reduction.output.gamma_pow_2",
+            "stage6.inc_claim_reduction.output.term2",
+            "stage6.inc_claim_reduction.output.gamma_pow_3",
+            "stage6.inc_claim_reduction.output.term3",
+            "stage6.inc_claim_reduction.output.claim_expr"
+        ]
+    );
+    let inc_claims = verifier_program
+        .relation_outputs
+        .iter()
+        .filter(|claim| {
+            claim.expected_output_symbol() == "stage6.inc_claim_reduction.output.claim_expr"
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(inc_claims.len(), 1);
+    let booleanity_claims = verifier_program
+        .relation_outputs
+        .iter()
+        .filter(|claim| claim.expected_output_symbol() == "stage6.booleanity.output.claim_expr")
+        .collect::<Vec<_>>();
+    assert_eq!(booleanity_claims.len(), 1);
+    assert!(verifier_program
+        .scalar_exprs
+        .iter()
+        .any(|expr| expr.symbol == "stage6.booleanity.output.eq.InstructionRa0"));
+    let hamming_claims = verifier_program
+        .relation_outputs
+        .iter()
+        .filter(|claim| {
+            claim.expected_output_symbol() == "stage6.hamming_booleanity.output.claim_expr"
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(hamming_claims.len(), 1);
+    let ram_ra_claims = verifier_program
+        .relation_outputs
+        .iter()
+        .filter(|claim| claim.expected_output_symbol() == "stage6.ram_ra_virtual.output.claim_expr")
+        .collect::<Vec<_>>();
+    assert_eq!(ram_ra_claims.len(), 1);
+    let instruction_ra_claims = verifier_program
+        .relation_outputs
+        .iter()
+        .filter(|claim| {
+            claim.expected_output_symbol() == "stage6.instruction_ra_virtual.output.claim_expr"
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(instruction_ra_claims.len(), 1);
+    let bytecode_claims = verifier_program
+        .relation_outputs
+        .iter()
+        .filter(|claim| {
+            claim.expected_output_symbol() == "stage6.bytecode_read_raf.output.claim_expr"
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(bytecode_claims.len(), 1);
+    let bytecode_output_scalar_exprs = verifier_program
+        .scalar_exprs
+        .iter()
+        .filter(|expr| expr.symbol.starts_with("stage6.bytecode_read_raf.output."))
+        .collect::<Vec<_>>();
+    assert!(bytecode_output_scalar_exprs.iter().any(|expr| {
+        expr.symbol == "stage6.bytecode_read_raf.output.product.BytecodeRa"
+            && expr.formula == "field_vector.product"
+            && expr.operands == vec!["stage6.bytecode_read_raf.eval.BytecodeRa".to_owned()]
+    }));
+    let bytecode_output_exprs = verifier_program
+        .field_exprs
+        .iter()
+        .filter(|expr| expr.symbol.starts_with("stage6.bytecode_read_raf.output."))
+        .collect::<Vec<_>>();
+    assert!(bytecode_output_exprs.iter().any(|expr| {
+        expr.symbol == "stage6.bytecode_read_raf.output.claim_expr"
+            && expr.formula == "field.product"
+            && expr.operands
+                == vec![
+                    "stage6.bytecode_read_raf.output.contribution".to_owned(),
+                    "stage6.bytecode_read_raf.output.product.BytecodeRa".to_owned(),
+                ]
+    }));
     assert_eq!(prover_program.point_zeros.len(), 1);
     assert_eq!(
         prover_program.point_slices.len(),
-        params.bytecode_d + 1 + params.ram_d + params.instruction_d
+        params.bytecode_d + 3 + params.ram_d + params.instruction_d
     );
     assert_eq!(
         prover_program.point_concats.len(),
-        params.bytecode_d + 1 + params.ram_d + params.instruction_d
+        params.bytecode_d + 2 + params.ram_d + params.instruction_d
     );
     assert_eq!(
         prover_program.opening_claims.len(),
@@ -1537,36 +1855,175 @@ fn stage6_rust_targets_extract_and_compile() {
     assert!(verifier_source.source.contains("pub fn verify_stage6"));
     assert!(verifier_source
         .source
-        .contains("relation: Some(\"jolt.stage6.batched\")"));
+        .contains("relation: Some(Stage6RelationKind::Stage6Batched)"));
     assert!(verifier_source
         .source
-        .contains("jolt.stage6.bytecode_read_raf"));
+        .contains("Stage6RelationKind::Stage6BytecodeReadRaf"));
     assert!(verifier_source.source.contains("Stage6VerifierData"));
     assert!(verifier_source.source.contains("Stage6BytecodeReadRafData"));
     assert!(verifier_source.source.contains("Stage6BytecodeEntry"));
-    assert!(verifier_source
+    assert!(!verifier_source
         .source
         .contains("expected_bytecode_read_raf"));
+    assert!(verifier_source.source.contains("STAGE6_BYTECODE_PLAN"));
     assert!(verifier_source
         .source
-        .contains("stage6.bytecode_read_raf.data"));
-    assert!(verifier_source.source.contains("expected_booleanity"));
+        .contains("Stage67BytecodeReadRafPlan"));
+    assert!(verifier_source
+        .source
+        .contains("Stage67BytecodeTermPlan::LookupTable"));
     assert!(verifier_source
+        .source
+        .contains("Stage67BytecodeTermPlan::RegisterEq"));
+    assert!(verifier_source
+        .source
+        .contains("evaluate_stage67_bytecode_read_raf_output_scalars"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.bytecode_read_raf.output.product.BytecodeReadRaf"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.bytecode_read_raf.output.claim_expr"));
+    assert!(verifier_source
+        .source
+        .contains("Stage6ScalarExprKind::FieldVectorProduct"));
+    assert!(!verifier_source
+        .source
+        .contains("expected_stage67_bytecode_read_raf"));
+    assert!(!verifier_source.source.contains("Stage67BytecodeSymbols"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.bytecode_read_raf.data"));
+    assert!(!verifier_source.source.contains("expected_booleanity"));
+    assert!(!verifier_source
         .source
         .contains("expected_hamming_booleanity"));
     assert!(verifier_source
         .source
-        .contains("jolt.stage6.inc_claim_reduction"));
+        .contains("bolt_verifier_runtime::evaluate_relation_output_batch"));
     assert!(verifier_source
         .source
-        .contains("stage6.input.stage1.LookupOutput"));
-    assert!(verifier_source.source.contains("expected_ram_ra_virtual"));
+        .contains("stage6_relation_output_inputs"));
     assert!(verifier_source
         .source
-        .contains("expected_instruction_ra_virtual"));
+        .contains("stage6.booleanity.output.eq.InstructionRa0"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.booleanity.output.family"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.hamming_booleanity.output.eq.LookupOutput"));
+    assert!(verifier_source
+        .source
+        .contains("Stage6RelationKind::Stage6IncClaimReduction"));
     assert!(verifier_source
+        .source
+        .contains("stage6.input.stage1.LookupOutput"));
+    assert!(!verifier_source.source.contains("expected_ram_ra_virtual"));
+    assert!(!verifier_source
+        .source
+        .contains("expected_instruction_ra_virtual"));
+    assert!(!verifier_source
         .source
         .contains("expected_inc_claim_reduction"));
+    assert!(verifier_source.source.contains("Stage6RelationOutputPlan"));
+    assert!(!verifier_source
+        .source
+        .contains("RelationOutputFunctionFamilyPlan"));
+    assert!(!verifier_source
+        .source
+        .contains("STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES"));
+    assert!(!verifier_source
+        .source
+        .contains("STAGE6_RELATION_OUTPUT_4_FAMILIES"));
+    assert!(!verifier_source
+        .source
+        .contains("RelationOutputProductFamilyPlan"));
+    assert!(!verifier_source
+        .source
+        .contains("STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES"));
+    assert!(!verifier_source
+        .source
+        .contains("STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES"));
+    assert!(!verifier_source
+        .source
+        .contains("STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.booleanity.output.family"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.booleanity.output.eq.InstructionRa0"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.booleanity.output.gamma_sq_"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.hamming_booleanity.output.family"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.hamming_booleanity.output.claim_expr"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.hamming_booleanity.output.term0.boolean_zero"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.ram_ra_virtual.output.family"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.instruction_ra_virtual.output.family"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.inc_claim_reduction.output.eq.RdIncStage5"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.inc_claim_reduction.output.family"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.inc_claim_reduction.output.claim_expr"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.inc_claim_reduction.output.gamma_pow_3"));
+    assert!(verifier_source.source.contains("Stage6FieldExprKind::Sum"));
+    assert!(verifier_source
+        .source
+        .contains("Stage6FieldExprKind::Product"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.hamming_booleanity.output.square.HammingWeight"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.hamming_booleanity.output.neg.HammingWeight"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.hamming_booleanity.output.gamma_identity"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.ram_ra_virtual.output.product.RamRa"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.ram_ra_virtual.output.claim_expr"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.ram_ra_virtual.output.gamma_identity"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.instruction_ra_virtual.output.product.InstructionRa_0"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.instruction_ra_virtual.output.weighted_sum"));
+    assert!(!verifier_source
+        .source
+        .contains("stage6.instruction_ra_virtual.output.term.InstructionRa_"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.instruction_ra_virtual.output.gamma_pow_7"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.instruction_ra_virtual.output.claim_expr"));
+    assert!(verifier_source
+        .source
+        .contains("stage6.inc_claim_reduction.output.term0"));
     assert!(verifier_source
         .source
         .contains("stage6.bytecode_read_raf.eval.BytecodeRa_0"));
@@ -1578,7 +2035,7 @@ fn stage6_rust_targets_extract_and_compile() {
         .contains("stage6.inc_claim_reduction.eval.RdInc"));
     assert!(verifier_source
         .source
-        .contains("super::common::verify_batched_sumcheck"));
+        .contains("bolt_verifier_runtime::verify_batched_sumcheck"));
     assert!(verifier_source.source.contains("stage6_verifier_program"));
     assert_rust_source_compiles(&prover_source.filename, &prover_source.source);
     assert_rust_source_compiles(&verifier_source.filename, &verifier_source.source);
@@ -1609,6 +2066,52 @@ fn stage7_rust_targets_extract_and_compile() {
     assert_eq!(prover_program.drivers.len(), 1);
     assert_eq!(prover_program.instance_results.len(), 1);
     assert_eq!(prover_program.evals.len(), total_ra);
+    assert_eq!(prover_program.relation_output_values.len(), total_ra + 1);
+    assert!(prover_program.relation_outputs.is_empty());
+    assert_eq!(verifier_program.relation_output_values.len(), total_ra + 1);
+    assert!(verifier_program.relation_output_eval_families.is_empty());
+    assert_eq!(verifier_program.relation_outputs.len(), 1);
+    assert_eq!(
+        verifier_program.relation_outputs[0].expected_output_symbol(),
+        "stage7.hamming_weight_claim_reduction.output.claim_expr"
+    );
+    let input_claim = verifier_program
+        .claims
+        .iter()
+        .find(|claim| claim.symbol == "stage7.hamming_weight_claim_reduction.input")
+        .expect("stage7 hamming input claim exists");
+    assert_eq!(
+        input_claim.claim_value,
+        "stage7.hamming_weight_claim_reduction.input.claim_expr"
+    );
+    let input_expr = verifier_program
+        .scalar_exprs
+        .iter()
+        .find(|expr| expr.symbol == "stage7.hamming_weight_claim_reduction.input.claim_expr")
+        .expect("stage7 hamming input claim is lowered to a scalar expression");
+    assert_eq!(
+        input_expr.formula,
+        format!("field.power_strided_weighted_sum:{total_ra}:3:_:_:0,1,2")
+    );
+    assert_eq!(input_expr.operands.len(), 1 + total_ra + 3 * total_ra);
+    let output_expr = verifier_program
+        .scalar_exprs
+        .iter()
+        .find(|expr| expr.symbol == "stage7.hamming_weight_claim_reduction.output.claim_expr")
+        .expect("stage7 hamming output is lowered to a scalar expression");
+    assert_eq!(
+        output_expr.formula,
+        format!("field.power_strided_weighted_sum:{total_ra}:3:0:1:2")
+    );
+    assert_eq!(output_expr.operands.len(), 2 * total_ra + 2);
+    assert_eq!(
+        output_expr.operands[0],
+        "stage7.hamming_weight_claim_reduction.gamma"
+    );
+    assert_eq!(
+        output_expr.operands[1 + total_ra],
+        "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"
+    );
     assert!(prover_program.point_zeros.is_empty());
     assert_eq!(prover_program.point_slices.len(), 1);
     assert_eq!(prover_program.point_concats.len(), 1);
@@ -1650,13 +2153,41 @@ fn stage7_rust_targets_extract_and_compile() {
     assert!(verifier_source.source.contains("pub fn verify_stage7"));
     assert!(verifier_source
         .source
-        .contains("relation: Some(\"jolt.stage7.batched\")"));
+        .contains("relation: Some(Stage7RelationKind::Stage7Batched)"));
     assert!(verifier_source
         .source
-        .contains("jolt.stage7.hamming_weight_claim_reduction"));
-    assert!(verifier_source
+        .contains("Stage7RelationKind::Stage7HammingWeightClaimReduction"));
+    assert!(!verifier_source
         .source
         .contains("expected_hamming_weight_claim_reduction"));
+    assert!(verifier_source.source.contains("Stage7RelationOutputPlan"));
+    assert!(!verifier_source
+        .source
+        .contains("RelationOutputEvalFamilyPlan"));
+    assert!(!verifier_source
+        .source
+        .contains("STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS"));
+    assert!(verifier_source
+        .source
+        .contains("Stage7ScalarExprKind::PowerStridedWeightedSum"));
+    assert!(!verifier_source
+        .source
+        .contains("Stage7FieldExprKind::PowerStridedWeightedSum"));
+    assert!(!verifier_source
+        .source
+        .contains("stage7.hamming_weight_claim_reduction.claim_expr.partial"));
+    assert!(verifier_source
+        .source
+        .contains("stage7.hamming_weight_claim_reduction.output.eq.Booleanity"));
+    assert!(verifier_source.source.contains(
+        "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization"
+    ));
+    assert!(!verifier_source
+        .source
+        .contains("stage7.hamming_weight_claim_reduction.output.term"));
+    assert!(verifier_source
+        .source
+        .contains("bolt_verifier_runtime::evaluate_relation_output_batch"));
     assert!(verifier_source
         .source
         .contains("stage7.input.stage6.booleanity.InstructionRa_0"));
@@ -1665,7 +2196,7 @@ fn stage7_rust_targets_extract_and_compile() {
         .contains("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0"));
     assert!(verifier_source
         .source
-        .contains("super::common::verify_batched_sumcheck"));
+        .contains("bolt_verifier_runtime::verify_batched_sumcheck"));
     assert!(verifier_source.source.contains("stage7_verifier_program"));
     assert_rust_source_compiles(&prover_source.filename, &prover_source.source);
     assert_rust_source_compiles(&verifier_source.filename, &verifier_source.source);
@@ -1717,7 +2248,9 @@ fn stage8_rust_targets_extract_and_compile() {
     assert!(prover_source
         .source
         .contains("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0"));
-    assert!(verifier_source.source.contains("mode: \"verify\""));
+    assert!(verifier_source
+        .source
+        .contains("mode: Stage8PcsProofMode::Verify"));
     assert_rust_source_compiles(&prover_source.filename, &prover_source.source);
     assert_rust_source_compiles(&verifier_source.filename, &verifier_source.source);
 }
@@ -3122,6 +3655,16 @@ module @explicit.sumcheck attributes {bolt.phase = "protocol"} {
 "#
 }
 
+fn explicit_sumcheck_protocol_with_eval_family(count: usize, evals: &str) -> String {
+    explicit_sumcheck_protocol().replace(
+        r#"  %opening = "pcs.opening_claim""#,
+        &format!(
+            r#"  "piop.sumcheck_eval_family"() {{count = {count} : i64, evals = {evals}, oracle_family = @RdInc, source = @stage1.outer.sumcheck, sym_name = "stage1.outer.eval.family"}} : () -> ()
+  %opening = "pcs.opening_claim""#
+        ),
+    )
+}
+
 fn explicit_sumcheck_compute() -> &'static str {
     r#"
 module @explicit.sumcheck attributes {bolt.phase = "compute", bolt.role = "prover"} {
@@ -3170,16 +3713,18 @@ fn assert_rust_source_compiles(_filename: &str, source: &str) {
     )
     .expect("write generated cargo manifest");
     std::fs::create_dir_all(dir.join("src")).expect("create generated src dir");
-    if source.contains("super::common") {
+    if source.contains("super::jolt_relations") {
+        // Tier B: audited Jolt verifier core. Tier A is provided by the
+        // bolt-verifier-runtime crate and is not staged as generated source.
         std::fs::write(
-            dir.join("src/common.rs"),
-            generated_verifier_common_source(&workspace_root),
+            dir.join("src/jolt_relations.rs"),
+            generated_verifier_jolt_relations_source(&workspace_root),
         )
-        .expect("write generated common source");
+        .expect("write generated jolt_relations source");
         std::fs::write(dir.join("src/generated.rs"), source).expect("write generated source");
         std::fs::write(
             dir.join("src/lib.rs"),
-            "pub mod common;\n#[rustfmt::skip]\npub mod generated;\n",
+            "pub mod jolt_relations;\n#[rustfmt::skip]\npub mod generated;\n",
         )
         .expect("write generated lib wrapper");
     } else {
@@ -3367,9 +3912,9 @@ fn assert_generated_stage1_self_parity_runs(
     .expect("write generated cargo manifest");
     let src_dir = dir.join("src");
     std::fs::create_dir_all(&src_dir).expect("create generated src dir");
-    let main_source = if verifier_source.source.contains("super::common") {
-        write_verifier_common_module(&src_dir, &workspace_root);
-        format!("mod common;\n{main_source}")
+    let main_source = if verifier_source.source.contains("super::jolt_relations") {
+        write_verifier_jolt_relations_module(&src_dir, &workspace_root);
+        format!("mod jolt_relations;\n{main_source}")
     } else {
         main_source.to_owned()
     };
@@ -3417,10 +3962,10 @@ fn assert_generated_jolt_chain_self_parity_runs(files: &[&RustSourceFile], main_
     std::fs::create_dir_all(&src_dir).expect("create generated src dir");
     let main_source = if files
         .iter()
-        .any(|file| file.source.contains("super::common"))
+        .any(|file| file.source.contains("super::jolt_relations"))
     {
-        write_verifier_common_module(&src_dir, &workspace_root);
-        format!("mod common;\n{main_source}")
+        write_verifier_jolt_relations_module(&src_dir, &workspace_root);
+        format!("mod jolt_relations;\n{main_source}")
     } else {
         main_source.to_owned()
     };
@@ -3450,20 +3995,21 @@ fn assert_generated_jolt_chain_self_parity_runs(files: &[&RustSourceFile], main_
     let _ = std::fs::remove_dir_all(dir);
 }
 
-fn write_verifier_common_module(src_dir: &Path, workspace_root: &Path) {
+fn write_verifier_jolt_relations_module(src_dir: &Path, workspace_root: &Path) {
     std::fs::write(
-        src_dir.join("common.rs"),
-        generated_verifier_common_source(workspace_root),
+        src_dir.join("jolt_relations.rs"),
+        generated_verifier_jolt_relations_source(workspace_root),
     )
-    .expect("write generated common source");
+    .expect("write generated jolt_relations source");
 }
 
-fn generated_verifier_common_source(workspace_root: &Path) -> String {
-    let common =
-        std::fs::read_to_string(workspace_root.join("crates/jolt-verifier/src/stages/common.rs"))
-            .expect("read generated verifier common stage source");
+fn generated_verifier_jolt_relations_source(workspace_root: &Path) -> String {
+    let jolt_relations = std::fs::read_to_string(
+        workspace_root.join("crates/jolt-verifier/src/stages/jolt_relations.rs"),
+    )
+    .expect("read generated verifier jolt_relations stage source");
     format!(
-        "#![allow(dead_code, unused_imports, unused_macros, reason = \"generated verifier helpers are shared across generated stage subsets\")]\n{common}"
+        "#![allow(dead_code, unused_imports, unused_macros, reason = \"audited Jolt verifier core helpers are shared across generated stage subsets\")]\n{jolt_relations}"
     )
 }
 
@@ -3481,7 +4027,10 @@ fn generated_jolt_runtime_available() -> bool {
         .join("crates/jolt-kernels/Cargo.toml")
         .exists()
         && workspace_root
-            .join("crates/jolt-verifier/src/stages/common.rs")
+            .join("crates/bolt-verifier-runtime/Cargo.toml")
+            .exists()
+        && workspace_root
+            .join("crates/jolt-verifier/src/stages/jolt_relations.rs")
             .exists()
 }
 
@@ -3510,6 +4059,7 @@ ark-ff = {{ git = "https://github.com/a16z/arkworks-algebra", branch = "dev/twis
 ark-serialize = {{ git = "https://github.com/a16z/arkworks-algebra", branch = "dev/twist-shout" }}
 
 [dependencies]
+bolt-verifier-runtime = {{ path = "{}" }}
 jolt-dory = {{ path = "{}" }}
 jolt-field = {{ path = "{}" }}
 jolt-kernels = {{ path = "{}" }}
@@ -3524,6 +4074,9 @@ rayon = "1.12.0"
 serde = {{ version = "1.0", default-features = false, features = ["derive"] }}
 tracing = {{ version = "0.1.37", default-features = false, features = ["attributes"] }}
 "#,
+        workspace_root
+            .join("crates/bolt-verifier-runtime")
+            .display(),
         workspace_root.join("crates/jolt-dory").display(),
         workspace_root.join("crates/jolt-field").display(),
         workspace_root.join("crates/jolt-kernels").display(),
diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs
index 1a8318501f..f401f66b9e 100644
--- a/crates/bolt/tests/verifier_cleanup.rs
+++ b/crates/bolt/tests/verifier_cleanup.rs
@@ -6,20 +6,39 @@
 
 use std::path::{Path, PathBuf};
 
-const GENERATED_VERIFIER_TARGET_LOC: usize = 6_000;
+/// S2.5 keeps only Jolt-specific verifier-program data in generated
+/// `verifier.rs`; reusable program shape and dispatch live in
+/// `crates/bolt-verifier-runtime`.
+const GENERATED_VERIFIER_TARGET_LOC: usize = 6_500;
 const GENERATED_VERIFIER_STRETCH_LOC: usize = 3_000;
-const VERIFIER_RS_TARGET_LOC: usize = 500;
+const VERIFIER_RS_TARGET_LOC: usize = 850;
 const VERIFIER_RS_STRETCH_LOC: usize = 350;
 const STAGE6_STAGE7_TARGET_LOC: usize = 3_000;
 
 const GENERATED_VERIFIER_BASELINE_LOC_CEILING: usize = 9_185;
-const SHARED_RUNTIME_BASELINE_LOC_CEILING: usize = 1_900;
 const VERIFIER_RS_BASELINE_LOC_CEILING: usize = VERIFIER_RS_TARGET_LOC;
 const STAGE6_STAGE7_BASELINE_LOC_CEILING: usize = STAGE6_STAGE7_TARGET_LOC;
+
+/// Tier A ceiling inside the generated verifier crate. S2 moves generic Bolt
+/// verifier scaffolding into `crates/bolt-verifier-runtime`, so this generated
+/// surface should stay at zero after the extraction.
+const BOLT_RUNTIME_BASELINE_LOC_CEILING: usize = 0;
+
+/// Tier B ceiling: hand-written Jolt verifier math lives in
+/// `stages/jolt_relations.rs`. Growth here is a *protocol-math* decision and
+/// should be reviewed as such, not as emitter-LOC creep.
+const JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING: usize = 700;
 const STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING: usize = 18;
 const FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING: usize = 0;
+const BATCH_OPERAND_STRING_SITE_BASELINE_CEILING: usize = 0;
+const CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING: usize = 0;
+const POINT_CONCAT_INPUT_STRING_SITE_BASELINE_CEILING: usize = 0;
+const STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING: usize = 0;
 const STAGE_HELPER_FUNCTION_BASELINE_CEILING: usize = 38;
-const RELATION_STRING_SITE_BASELINE_CEILING: usize = 72;
+const RELATION_STRING_SITE_BASELINE_CEILING: usize = 0;
+const SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING: usize = 0;
+const RELATION_INDEXED_EVAL_PREFIX_SITE_BASELINE_CEILING: usize = 0;
+const HANDWRITTEN_EXPECTED_OUTPUT_FUNCTION_BASELINE_CEILING: usize = 12;
 
 const ALLOWED_JOLT_PROTOCOL_SYMBOLS: &[&str] = &[
     "jolt.commitment_phase",
@@ -109,13 +128,28 @@ const GENERIC_COMPILER_JOLT_PATTERNS: &[&str] = &[
 struct VerifierCleanupMetrics {
     total_loc: usize,
     generated_surface_loc: usize,
-    shared_runtime_loc: usize,
+    /// Tier A: generic Bolt verifier scaffolding still emitted inside
+    /// `crates/jolt-verifier/src` after extraction.
+    bolt_runtime_loc: usize,
+    /// Tier B: audited Jolt verifier core
+    /// (`crates/jolt-verifier/src/stages/jolt_relations.rs`).
+    jolt_verifier_core_loc: usize,
     verifier_rs_loc: usize,
     stage6_stage7_loc: usize,
     stage_local_generic_plan_structs: usize,
     field_expr_operand_constants: usize,
+    batch_operand_string_sites: usize,
+    claim_input_opening_string_sites: usize,
+    point_concat_input_string_sites: usize,
+    stage_local_macro_rules: usize,
     stage_local_helper_functions: usize,
     relation_string_sites: usize,
+    sumcheck_point_order_string_sites: usize,
+    relation_indexed_eval_prefix_sites: usize,
+    compute_poly_op_call_sites: usize,
+    compute_point_op_call_sites: usize,
+    value_graph_relation_outputs: usize,
+    handwritten_expected_output_functions: usize,
 }
 
 #[test]
@@ -129,17 +163,30 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() {
     eprintln!(
         "\nGenerated verifier cleanup metrics\n\
          generated_surface_loc: {generated_surface_loc} (target <= {target_loc}, stretch <= {stretch_loc})\n\
-         shared_runtime_loc: {shared_runtime_loc} (baseline ceiling <= {shared_runtime_baseline})\n\
+         tier_a_bolt_runtime_loc: {bolt_runtime_loc} (baseline ceiling <= {bolt_runtime_baseline}; Tier A: generic Bolt scaffolding)\n\
+         tier_b_jolt_verifier_core_loc: {jolt_verifier_core_loc} (baseline ceiling <= {jolt_core_baseline}; Tier B: audited Jolt verifier math)\n\
          total_loc: {total_loc} (baseline ceiling <= {baseline_loc})\n\
          verifier_rs_loc: {verifier_rs_loc} (target <= {verifier_target}, stretch <= {verifier_stretch}, baseline ceiling <= {verifier_baseline})\n\
          stage6_stage7_loc: {stage6_stage7_loc} (target <= {stage67_target}, baseline ceiling <= {stage67_baseline})\n\
          stage_local_generic_plan_structs: {plan_structs} (baseline ceiling <= {plan_baseline})\n\
          field_expr_operand_constants: {operand_constants} (baseline ceiling <= {operand_baseline})\n\
+         batch_operand_string_sites: {batch_operand_string_sites} (baseline ceiling <= {batch_operand_baseline})\n\
+         claim_input_opening_string_sites: {claim_input_opening_string_sites} (baseline ceiling <= {claim_input_opening_baseline})\n\
+         point_concat_input_string_sites: {point_concat_input_string_sites} (baseline ceiling <= {point_concat_input_baseline})\n\
+         stage_local_macro_rules: {stage_local_macro_rules} (baseline ceiling <= {macro_rules_baseline})\n\
          stage_local_helper_functions: {helper_functions} (baseline ceiling <= {helper_baseline})\n\
-         relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})",
+         relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})\n\
+         sumcheck_point_order_string_sites: {point_order_sites} (baseline ceiling <= {point_order_baseline})\n\
+         relation_indexed_eval_prefix_sites: {indexed_eval_prefix_sites} (baseline ceiling <= {indexed_eval_prefix_baseline})\n\
+         compute_poly_op_call_sites: {compute_poly_op_call_sites}\n\
+         compute_point_op_call_sites: {compute_point_op_call_sites}\n\
+         value_graph_relation_outputs: {value_graph_relation_outputs}\n\
+         handwritten_expected_output_functions: {expected_output_functions} (baseline ceiling <= {expected_output_functions_baseline})",
         generated_surface_loc = metrics.generated_surface_loc,
-        shared_runtime_loc = metrics.shared_runtime_loc,
-        shared_runtime_baseline = SHARED_RUNTIME_BASELINE_LOC_CEILING,
+        bolt_runtime_loc = metrics.bolt_runtime_loc,
+        bolt_runtime_baseline = BOLT_RUNTIME_BASELINE_LOC_CEILING,
+        jolt_verifier_core_loc = metrics.jolt_verifier_core_loc,
+        jolt_core_baseline = JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING,
         total_loc = metrics.total_loc,
         target_loc = GENERATED_VERIFIER_TARGET_LOC,
         stretch_loc = GENERATED_VERIFIER_STRETCH_LOC,
@@ -155,30 +202,58 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() {
         plan_baseline = STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING,
         operand_constants = metrics.field_expr_operand_constants,
         operand_baseline = FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING,
+        batch_operand_string_sites = metrics.batch_operand_string_sites,
+        batch_operand_baseline = BATCH_OPERAND_STRING_SITE_BASELINE_CEILING,
+        claim_input_opening_string_sites = metrics.claim_input_opening_string_sites,
+        claim_input_opening_baseline = CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING,
+        point_concat_input_string_sites = metrics.point_concat_input_string_sites,
+        point_concat_input_baseline = POINT_CONCAT_INPUT_STRING_SITE_BASELINE_CEILING,
+        stage_local_macro_rules = metrics.stage_local_macro_rules,
+        macro_rules_baseline = STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING,
         helper_functions = metrics.stage_local_helper_functions,
         helper_baseline = STAGE_HELPER_FUNCTION_BASELINE_CEILING,
         relation_sites = metrics.relation_string_sites,
         relation_baseline = RELATION_STRING_SITE_BASELINE_CEILING,
+        point_order_sites = metrics.sumcheck_point_order_string_sites,
+        point_order_baseline = SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING,
+        indexed_eval_prefix_sites = metrics.relation_indexed_eval_prefix_sites,
+        indexed_eval_prefix_baseline = RELATION_INDEXED_EVAL_PREFIX_SITE_BASELINE_CEILING,
+        compute_poly_op_call_sites = metrics.compute_poly_op_call_sites,
+        compute_point_op_call_sites = metrics.compute_point_op_call_sites,
+        value_graph_relation_outputs = metrics.value_graph_relation_outputs,
+        expected_output_functions = metrics.handwritten_expected_output_functions,
+        expected_output_functions_baseline =
+            HANDWRITTEN_EXPECTED_OUTPUT_FUNCTION_BASELINE_CEILING,
     );
 
     assert!(
         metrics.generated_surface_loc <= GENERATED_VERIFIER_TARGET_LOC,
-        "generated verifier surface is {} LOC; keep reducing generated stage/orchestration code or intentionally update the cleanup target",
-        metrics.generated_surface_loc
+        "generated verifier surface grew to {} LOC; keep stage files thin (target <= {})",
+        metrics.generated_surface_loc,
+        GENERATED_VERIFIER_TARGET_LOC,
     );
-    assert!(
-        metrics.generated_surface_loc > GENERATED_VERIFIER_STRETCH_LOC,
-        "cleanup metric reached the stretch target; tighten the generated verifier surface gate"
+    if metrics.generated_surface_loc <= GENERATED_VERIFIER_STRETCH_LOC {
+        eprintln!(
+            "[verifier_cleanup] notice: generated_surface_loc = {} reached stretch target {}; \
+             tighten GENERATED_VERIFIER_TARGET_LOC",
+            metrics.generated_surface_loc, GENERATED_VERIFIER_STRETCH_LOC,
+        );
+    }
+    assert_eq!(
+        metrics.bolt_runtime_loc, BOLT_RUNTIME_BASELINE_LOC_CEILING,
+        "Tier A bolt verifier runtime grew to {} LOC (ceiling {}); generic Bolt scaffolding should ratchet down, not up",
+        metrics.bolt_runtime_loc, BOLT_RUNTIME_BASELINE_LOC_CEILING
     );
     assert!(
-        metrics.shared_runtime_loc <= SHARED_RUNTIME_BASELINE_LOC_CEILING,
-        "shared verifier runtime grew to {} LOC; keep generic runtime small and audited",
-        metrics.shared_runtime_loc
+        metrics.jolt_verifier_core_loc <= JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING,
+        "Tier B audited Jolt verifier core grew to {} LOC (ceiling {}); growth here must be reviewed as a protocol-math decision",
+        metrics.jolt_verifier_core_loc, JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING,
     );
     assert!(
         metrics.total_loc <= GENERATED_VERIFIER_BASELINE_LOC_CEILING,
-        "checked-in verifier grew to {} LOC; lower generated/runtime surface, or intentionally update the cleanup baseline",
-        metrics.total_loc
+        "generated verifier total grew to {} LOC (ceiling {})",
+        metrics.total_loc,
+        GENERATED_VERIFIER_BASELINE_LOC_CEILING,
     );
     assert!(
         metrics.verifier_rs_loc <= VERIFIER_RS_BASELINE_LOC_CEILING,
@@ -187,8 +262,9 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() {
     );
     assert!(
         metrics.stage6_stage7_loc <= STAGE6_STAGE7_BASELINE_LOC_CEILING,
-        "Stage 6/7 generated verifier surface grew to {} LOC; compact plan data before adding more generated code",
-        metrics.stage6_stage7_loc
+        "stage6 + stage7 grew to {} LOC (ceiling {})",
+        metrics.stage6_stage7_loc,
+        STAGE6_STAGE7_BASELINE_LOC_CEILING,
     );
     assert!(
         metrics.stage_local_generic_plan_structs <= STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING,
@@ -200,16 +276,55 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() {
         "field-expression operand constants grew to {}; compact field expression encoding",
         metrics.field_expr_operand_constants
     );
+    assert!(
+        metrics.batch_operand_string_sites == BATCH_OPERAND_STRING_SITE_BASELINE_CEILING,
+        "batch operand string sites grew to {}; prefer structured claim slices",
+        metrics.batch_operand_string_sites
+    );
+    assert!(
+        metrics.claim_input_opening_string_sites
+            == CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING,
+        "claim input-opening string sites grew to {}; prefer structured input-opening slices",
+        metrics.claim_input_opening_string_sites
+    );
+    assert!(
+        metrics.point_concat_input_string_sites == POINT_CONCAT_INPUT_STRING_SITE_BASELINE_CEILING,
+        "point-concat input string sites grew to {}; prefer structured point input slices",
+        metrics.point_concat_input_string_sites
+    );
+    assert!(
+        metrics.stage_local_macro_rules == STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING,
+        "stage-local macro_rules sites grew to {}; prefer named constructors or shared runtime helpers",
+        metrics.stage_local_macro_rules
+    );
     assert!(
         metrics.stage_local_helper_functions <= STAGE_HELPER_FUNCTION_BASELINE_CEILING,
         "stage-local helper function count grew to {}; factor verifier mechanics into shared runtime",
         metrics.stage_local_helper_functions
     );
     assert!(
-        metrics.relation_string_sites <= RELATION_STRING_SITE_BASELINE_CEILING,
+        metrics.relation_string_sites == RELATION_STRING_SITE_BASELINE_CEILING,
         "relation string sites grew to {}; prefer typed relation plan data or explicit allowlists",
         metrics.relation_string_sites
     );
+    assert!(
+        metrics.sumcheck_point_order_string_sites
+            == SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING,
+        "sumcheck point-order string sites grew to {}; prefer typed point-order plan data",
+        metrics.sumcheck_point_order_string_sites
+    );
+    assert!(
+        metrics.relation_indexed_eval_prefix_sites
+            == RELATION_INDEXED_EVAL_PREFIX_SITE_BASELINE_CEILING,
+        "relation indexed-eval prefix sites grew to {}; prefer typed eval-family plan data",
+        metrics.relation_indexed_eval_prefix_sites
+    );
+    assert!(
+        metrics.handwritten_expected_output_functions
+            <= HANDWRITTEN_EXPECTED_OUTPUT_FUNCTION_BASELINE_CEILING,
+        "handwritten expected-output helper count grew to {}; move output math into typed value-graph plan data",
+        metrics.handwritten_expected_output_functions
+    );
 }
 
 #[test]
@@ -266,6 +381,194 @@ fn checked_in_generated_verifier_respects_boundary_hygiene() {
     }
 }
 
+#[test]
+fn checked_in_generated_verifier_uses_typed_top_level_program() {
+    let verifier_rs = workspace_root().join("crates/jolt-verifier/src/verifier.rs");
+    if !verifier_rs.exists() {
+        return;
+    }
+    let source = std::fs::read_to_string(&verifier_rs).expect("read verifier.rs");
+    for pattern in [
+        "pub const VERIFIER_PROGRAM",
+        "pub const JOLT_VERIFIER_STEPS",
+        "pub enum JoltProofSlot",
+        "pub enum JoltVerifierCheckpoint",
+        "pub type JoltVerifierStepKind = bolt_verifier_runtime::VerifierProgramStepKind",
+        "pub type JoltVerifierStepPlan = bolt_verifier_runtime::VerifierProgramStepPlan<JoltProofSlot>",
+        "pub type JoltVerifierTargetPlan = bolt_verifier_runtime::VerifierTargetPlan<JoltVerifierCheckpoint>",
+        "JoltVerifierStepKind::ReceiveCommitments",
+        "JoltVerifierStepKind::VerifySumcheckStage",
+        "JoltVerifierStepKind::VerifyPcsOpening",
+        "step_count:",
+        "bolt_verifier_runtime::execute_verifier_program",
+        "fn execute_jolt_verifier_program",
+        "fn execute_jolt_verifier_step",
+        "struct JoltArtifactStore",
+    ] {
+        assert!(
+            source.contains(pattern),
+            "generated verifier.rs is missing typed top-level verifier-program pattern `{pattern}`"
+        );
+    }
+    for stale_pattern in [
+        "JoltVerifierTarget::ThroughStage",
+        "fn verifies_stage6",
+        "fn verifies_stage7",
+        "fn verifies_evaluation",
+        "fn allows_optional_evaluation",
+        "target.verifies_stage",
+        "target.allows_optional_evaluation",
+    ] {
+        assert!(
+            !source.contains(stale_pattern),
+            "generated verifier.rs still contains stale target-control-flow pattern `{stale_pattern}`"
+        );
+    }
+}
+
+#[test]
+fn stage67_output_plan_cutover_removed_obsolete_relation_helpers() {
+    let root = workspace_root();
+    let generated_relations = root.join("crates/jolt-verifier/src/stages/jolt_relations.rs");
+    if !generated_relations.exists() {
+        return;
+    }
+
+    let relation_sources = [
+        generated_relations,
+        root.join("crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template"),
+    ];
+    for path in relation_sources {
+        let source = std::fs::read_to_string(&path).expect("read Jolt relation source");
+        for stale in [
+            "expected_stage67_bytecode_read_raf",
+            "expected_stage67_booleanity",
+            "expected_stage67_hamming_booleanity",
+            "expected_stage67_ram_ra_virtual",
+            "expected_stage67_instruction_ra_virtual",
+            "expected_stage67_inc_claim_reduction",
+        ] {
+            assert!(
+                !source.contains(stale),
+                "`{}` still contains obsolete Stage 6/7 relation helper `{stale}`",
+                path.display()
+            );
+        }
+    }
+
+    let stage6_source =
+        std::fs::read_to_string(root.join("crates/jolt-verifier/src/stages/stage6.rs"))
+            .expect("read generated Stage 6 verifier source");
+    for stale_field in [
+        "booleanity_point",
+        "stage5_instruction_ra0",
+        "booleanity_combined_point",
+        "booleanity_instruction_ra_prefix",
+        "booleanity_bytecode_ra_prefix",
+        "booleanity_ram_ra_prefix",
+        "hamming_weight_eval",
+        "hamming_lookup_output",
+        "ram_ra_virtual_cycle",
+        "ram_ra_virtual_eval_prefix",
+        "instruction_ra_virtual_cycle",
+        "instruction_ra_virtual_eval_prefix",
+        "instruction_ra_virtual_input_prefix",
+        "instruction_ra_virtual_gamma",
+        "inc_ram_stage2",
+        "inc_ram_stage4",
+        "inc_rd_stage4",
+        "inc_rd_stage5",
+        "inc_gamma",
+        "inc_ram_eval",
+        "inc_rd_eval",
+    ] {
+        assert!(
+            !stage6_source.contains(stale_field),
+            "generated Stage 6 relation symbol table still exposes obsolete field `{stale_field}`"
+        );
+    }
+}
+
+#[test]
+fn verifier_runtime_has_no_indexed_eval_prefix_api() {
+    let runtime = workspace_root().join("crates/bolt-verifier-runtime/src/lib.rs");
+    if !runtime.exists() {
+        return;
+    }
+    let source = std::fs::read_to_string(&runtime).expect("read verifier runtime source");
+    for stale in ["indexed_evals_by_prefix", "eval_prefix"] {
+        assert!(
+            !source.contains(stale),
+            "bolt-verifier-runtime still exposes indexed eval-prefix API `{stale}`"
+        );
+    }
+}
+
+#[test]
+fn verifier_runtime_has_no_name_then_position_eval_fallback() {
+    let runtime = workspace_root().join("crates/bolt-verifier-runtime/src/lib.rs");
+    if !runtime.exists() {
+        return;
+    }
+    let source = std::fs::read_to_string(&runtime).expect("read verifier runtime source");
+    for stale in [
+        ".or_else(|| output.evals.get(eval.index))",
+        "output.evals.get(eval.index)",
+    ] {
+        assert!(
+            !source.contains(stale),
+            "bolt-verifier-runtime still accepts sumcheck evals by position fallback `{stale}`"
+        );
+    }
+}
+
+#[test]
+fn verifier_runtime_has_no_jolt_specific_sumcheck_point_orders() {
+    let runtime = workspace_root().join("crates/bolt-verifier-runtime/src/lib.rs");
+    if !runtime.exists() {
+        return;
+    }
+    let source = std::fs::read_to_string(&runtime).expect("read verifier runtime source");
+    for stale in [
+        "Stage4RegistersReadWrite",
+        "InstructionReadRaf",
+        "BytecodeReadRaf",
+        "Stage6Booleanity",
+        "stage4_registers_rw",
+        "instruction_read_raf",
+        "bytecode_read_raf",
+        "stage6_booleanity",
+    ] {
+        assert!(
+            !source.contains(stale),
+            "bolt-verifier-runtime still exposes Jolt-specific point order `{stale}`"
+        );
+    }
+}
+
+#[test]
+fn verifier_goal_doc_tracks_extracted_runtime_boundary() {
+    let goal = workspace_root().join("crates/bolt/GOAL.md");
+    if !goal.exists() {
+        return;
+    }
+    let source = std::fs::read_to_string(&goal).expect("read verifier goal doc");
+    assert!(
+        source.contains("crates/bolt-verifier-runtime/src/lib.rs"),
+        "GOAL.md should name the extracted Bolt verifier runtime crate as Tier A"
+    );
+    for stale in [
+        "crates/jolt-verifier/src/stages/common.rs",
+        "crates/bolt/src/protocols/jolt/verifier_common.rs.template",
+        "shared verifier plan/runtime scaffolding exists in stages/common.rs",
+    ] {
+        assert!(
+            !source.contains(stale),
+            "GOAL.md still references deleted Tier A path `{stale}`"
+        );
+    }
+}
+
 #[test]
 fn verifier_cpu_fixtures_are_kernel_free() {
     let fixtures = workspace_root().join("crates/bolt/tests/fixtures");
@@ -413,7 +716,9 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics {
         let line_count = source.lines().count();
         metrics.total_loc += line_count;
         if relative == Path::new("stages/common.rs") {
-            metrics.shared_runtime_loc += line_count;
+            metrics.bolt_runtime_loc += line_count;
+        } else if relative == Path::new("stages/jolt_relations.rs") {
+            metrics.jolt_verifier_core_loc += line_count;
         } else {
             metrics.generated_surface_loc += line_count;
         }
@@ -423,12 +728,29 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics {
         if relative == Path::new("stages/stage6.rs") || relative == Path::new("stages/stage7.rs") {
             metrics.stage6_stage7_loc += line_count;
         }
+        if relative.to_string_lossy().starts_with("stages/stage") {
+            metrics.stage_local_macro_rules += count_stage_local_macro_rules(&source);
+        }
         if relative.starts_with("stages") {
             metrics.stage_local_generic_plan_structs +=
                 count_stage_local_generic_plan_structs(&source);
             metrics.field_expr_operand_constants += count_field_expr_operand_constants(&source);
+            metrics.batch_operand_string_sites += count_batch_operand_string_sites(&source);
+            metrics.claim_input_opening_string_sites +=
+                count_claim_input_opening_string_sites(&source);
+            metrics.point_concat_input_string_sites +=
+                count_point_concat_input_string_sites(&source);
             metrics.stage_local_helper_functions += count_stage_local_helper_functions(&source);
             metrics.relation_string_sites += count_relation_string_sites(&source);
+            metrics.sumcheck_point_order_string_sites +=
+                count_sumcheck_point_order_string_sites(&source);
+            metrics.relation_indexed_eval_prefix_sites +=
+                count_relation_indexed_eval_prefix_sites(&source);
+            metrics.compute_poly_op_call_sites += count_compute_poly_op_call_sites(&source);
+            metrics.compute_point_op_call_sites += count_compute_point_op_call_sites(&source);
+            metrics.value_graph_relation_outputs += count_value_graph_relation_outputs(&source);
+            metrics.handwritten_expected_output_functions +=
+                count_handwritten_expected_output_functions(&source);
         }
     }
     metrics
@@ -456,6 +778,9 @@ fn count_stage_local_generic_plan_structs(source: &str) -> usize {
         .lines()
         .filter(|line| {
             let line = line.trim_start();
+            if line.starts_with("pub type Stage") && line.contains("bolt_verifier_runtime::") {
+                return false;
+            }
             (line.starts_with("pub struct Stage") || line.starts_with("pub type Stage"))
                 && PLAN_SUFFIXES.iter().any(|suffix| line.contains(suffix))
         })
@@ -469,6 +794,34 @@ fn count_field_expr_operand_constants(source: &str) -> usize {
         .count()
 }
 
+fn count_batch_operand_string_sites(source: &str) -> usize {
+    source
+        .lines()
+        .filter(|line| line.contains("ordered_claims: \"") || line.contains("claim_operands: \""))
+        .count()
+}
+
+fn count_claim_input_opening_string_sites(source: &str) -> usize {
+    source
+        .lines()
+        .filter(|line| line.contains("input_openings: \""))
+        .count()
+}
+
+fn count_point_concat_input_string_sites(source: &str) -> usize {
+    source
+        .lines()
+        .filter(|line| line.contains("PointConcatPlan") && line.contains("inputs: \""))
+        .count()
+}
+
+fn count_stage_local_macro_rules(source: &str) -> usize {
+    source
+        .lines()
+        .filter(|line| line.trim_start().starts_with("macro_rules!"))
+        .count()
+}
+
 fn count_stage_local_helper_functions(source: &str) -> usize {
     const HELPER_PREFIXES: &[&str] = &[
         "fn evaluate_stage",
@@ -495,15 +848,54 @@ fn count_relation_string_sites(source: &str) -> usize {
     source
         .lines()
         .filter(|line| {
-            line.contains("match instance.relation")
-                || line.contains("match claim.relation")
-                || line.contains("match driver.relation")
-                || line.contains("relation: Some(\"jolt.")
+            line.contains("relation: Some(\"jolt.")
                 || line.contains("relation: \"jolt.")
+                || line.contains("relation == \"jolt.")
         })
         .count()
 }
 
+fn count_sumcheck_point_order_string_sites(source: &str) -> usize {
+    source
+        .lines()
+        .filter(|line| line.contains("point_order: \""))
+        .count()
+}
+
+fn count_relation_indexed_eval_prefix_sites(source: &str) -> usize {
+    source
+        .lines()
+        .filter(|line| line.contains("indexed_evals_by_prefix") || line.contains("eval_prefix"))
+        .count()
+}
+
+fn count_compute_poly_op_call_sites(source: &str) -> usize {
+    source
+        .matches("ScalarExprKind::StructuredPolynomial")
+        .count()
+}
+
+fn count_compute_point_op_call_sites(source: &str) -> usize {
+    source
+        .lines()
+        .filter(|line| line.contains("PointExprKind::") && line.contains("PointExprPlan"))
+        .count()
+}
+
+fn count_value_graph_relation_outputs(source: &str) -> usize {
+    source
+        .lines()
+        .filter(|line| line.contains("RelationOutputPlan {") && line.contains("expected_output:"))
+        .count()
+}
+
+fn count_handwritten_expected_output_functions(source: &str) -> usize {
+    source
+        .lines()
+        .filter(|line| line.trim_start().starts_with("fn expected_"))
+        .count()
+}
+
 fn assert_allowed_jolt_protocol_symbol(path: &Path, symbol: &str) {
     assert!(
         ALLOWED_JOLT_PROTOCOL_SYMBOLS.contains(&symbol),
diff --git a/crates/jolt-equivalence/Cargo.toml b/crates/jolt-equivalence/Cargo.toml
index 46207381dd..ba458b9f93 100644
--- a/crates/jolt-equivalence/Cargo.toml
+++ b/crates/jolt-equivalence/Cargo.toml
@@ -23,6 +23,7 @@ ark-serialize.workspace = true
 postcard.workspace = true
 
 # Bolt-generated Jolt path and shared modular primitives.
+bolt-verifier-runtime.workspace = true
 common = { path = "../../common" }
 jolt-field = { path = "../jolt-field", features = ["bn254"] }
 jolt-transcript = { path = "../jolt-transcript" }
diff --git a/crates/jolt-equivalence/src/bolt_oracle.rs b/crates/jolt-equivalence/src/bolt_oracle.rs
index 22441dcd2b..718ffe9764 100644
--- a/crates/jolt-equivalence/src/bolt_oracle.rs
+++ b/crates/jolt-equivalence/src/bolt_oracle.rs
@@ -139,6 +139,7 @@ pub fn assert_bolt_full_real_trace_self_parity(
         stage5: generated_stage5_verifier_plan,
         stage6: generated_stage6_verifier_plan,
         stage7: generated_stage7_verifier_plan,
+        verifier: &jolt_verifier::VERIFIER_PROGRAM,
         stage8: generated_stage8_verifier_plan,
     };
     let r1cs_key = fixture.r1cs_key();
diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs
index b577452cbf..aa9501aa24 100644
--- a/crates/jolt-equivalence/src/plan_adapters.rs
+++ b/crates/jolt-equivalence/src/plan_adapters.rs
@@ -1,17 +1,8 @@
 //! Static plan adapters from Bolt compiler plans to generated/kernel plans.
 //!
-//! These are compatibility shims for the equivalence oracle. They translate
-//! Bolt's owned compiler plans into the currently generated static plan shape
-//! expected by jolt-kernels, jolt-prover, and jolt-verifier.
-
-macro_rules! stage_list {
-    (kernel, $values:expr) => {
-        super::leak_str_slice($values)
-    };
-    (generated, $values:expr) => {
-        super::leak_symbol_list($values)
-    };
-}
+//! The equivalence oracle compares Bolt's owned compiler plans against the
+//! generated static plans expected by jolt-kernels, jolt-prover, and
+//! jolt-verifier. These adapters keep that comparison explicit.
 
 macro_rules! stage_field_expr {
     (kernel, $module:ident, $field_expr:ident, $plan:ident) => {
@@ -26,15 +17,82 @@ macro_rules! stage_field_expr {
     (generated, $module:ident, $field_expr:ident, $plan:ident) => {
         $module::$field_expr {
             symbol: super::leak_str(&$plan.symbol),
-            kind: super::leak_str(&$plan.kind),
-            formula: super::leak_str(&$plan.formula),
-            operands: super::leak_symbol_list(&$plan.operands),
+            kind: super::generated_field_expr_kind($plan.formula.as_str()),
+            operands: super::leak_str_slice(&$plan.operands),
         }
     };
 }
 
+macro_rules! stage_scalar_expr {
+    (generated, $module:ident, $scalar_expr:ident, $plan:ident) => {
+        $module::$scalar_expr {
+            symbol: super::leak_str(&$plan.symbol),
+            kind: super::generated_scalar_expr_kind($plan.formula.as_str()),
+            operands: super::leak_str_slice(&$plan.operands),
+        }
+    };
+}
+
+macro_rules! stage_generated_point_exprs {
+    ($module:ident, $point_expr:ident, $program:ident $(, point_zero = $point_zero:ident)?) => {{
+        let mut exprs = Vec::new();
+        $(
+        let _ = stringify!($point_zero);
+        exprs.extend($program.point_zeros.iter().map(|plan| {
+            $module::$point_expr {
+                symbol: super::leak_str(&plan.symbol),
+                kind: bolt_verifier_runtime::PointExprKind::Zero {
+                    field: super::leak_str(&plan.field),
+                    arity: plan.arity,
+                },
+                operands: &[],
+            }
+        }));
+        )?
+        exprs.extend($program.point_slices.iter().map(|plan| {
+            $module::$point_expr {
+                symbol: super::leak_str(&plan.symbol),
+                kind: bolt_verifier_runtime::PointExprKind::Slice {
+                    offset: plan.offset,
+                    length: plan.length,
+                },
+                operands: super::leak_str_slice(std::slice::from_ref(&plan.input)),
+            }
+        }));
+        exprs.extend($program.point_concats.iter().map(|plan| {
+            $module::$point_expr {
+                symbol: super::leak_str(&plan.symbol),
+                kind: bolt_verifier_runtime::PointExprKind::Concat {
+                    layout: super::leak_str(&plan.layout),
+                    arity: plan.arity,
+                },
+                operands: super::leak_str_slice(&plan.inputs),
+            }
+        }));
+        super::leak_slice(exprs)
+    }};
+}
+
+macro_rules! stage_optional_relation_kind {
+    (kernel, $value:expr) => {
+        $value.map(super::leak_str)
+    };
+    (generated, $value:expr) => {
+        $value.map(super::generated_relation_kind)
+    };
+}
+
+macro_rules! stage_sumcheck_point_order {
+    (kernel, $value:expr) => {
+        super::leak_str($value)
+    };
+    (generated, $value:expr) => {
+        super::generated_sumcheck_point_order($value)
+    };
+}
+
 macro_rules! stage_claim {
-    ($mode:ident, $module:ident, $claim:ident, $plan:ident) => {
+    (kernel, $module:ident, $claim:ident, $plan:ident) => {
         $module::$claim {
             symbol: super::leak_str(&$plan.symbol),
             stage: super::leak_str(&$plan.stage),
@@ -45,13 +103,56 @@ macro_rules! stage_claim {
             kernel: $plan.kernel.as_deref().map(super::leak_str),
             relation: $plan.relation.as_deref().map(super::leak_str),
             claim_value: super::leak_str(&$plan.claim_value),
-            input_openings: stage_list!($mode, &$plan.input_openings),
+            input_openings: super::leak_str_slice(&$plan.input_openings),
+        }
+    };
+    (generated, $module:ident, $claim:ident, $plan:ident) => {
+        $module::$claim {
+            symbol: super::leak_str(&$plan.symbol),
+            stage: super::leak_str(&$plan.stage),
+            domain: super::leak_str(&$plan.domain),
+            num_rounds: $plan.num_rounds,
+            degree: $plan.degree,
+            claim: super::leak_str(&$plan.claim),
+            kernel: $plan.kernel.as_deref().map(super::leak_str),
+            relation: stage_optional_relation_kind!(generated, $plan.relation.as_deref()),
+            claim_value: super::leak_str(&$plan.claim_value),
+        }
+    };
+}
+
+macro_rules! stage_sumcheck_batch {
+    (kernel, $module:ident, $batch:ident, $plan:ident) => {
+        $module::$batch {
+            symbol: super::leak_str(&$plan.symbol),
+            stage: super::leak_str(&$plan.stage),
+            proof_slot: super::leak_str(&$plan.proof_slot),
+            policy: super::leak_str(&$plan.policy),
+            count: $plan.count,
+            ordered_claims: super::leak_str_slice(&$plan.ordered_claims),
+            claim_operands: super::leak_str_slice(&$plan.claim_operands),
+            claim_label: super::leak_str(&$plan.claim_label),
+            round_label: super::leak_str(&$plan.round_label),
+            round_schedule: super::leak_usize_slice(&$plan.round_schedule),
+        }
+    };
+    (generated, $module:ident, $batch:ident, $plan:ident) => {
+        $module::$batch {
+            symbol: super::leak_str(&$plan.symbol),
+            stage: super::leak_str(&$plan.stage),
+            proof_slot: super::leak_str(&$plan.proof_slot),
+            policy: super::leak_str(&$plan.policy),
+            count: $plan.count,
+            claim_operands: super::leak_str_slice(&$plan.claim_operands),
+            claim_label: super::leak_str(&$plan.claim_label),
+            round_label: super::leak_str(&$plan.round_label),
+            round_schedule: super::leak_usize_slice(&$plan.round_schedule),
         }
     };
 }
 
 macro_rules! stage_driver {
-    ($module:ident, $driver:ident, $plan:ident) => {
+    (kernel, $module:ident, $driver:ident, $plan:ident) => {
         $module::$driver {
             symbol: super::leak_str(&$plan.symbol),
             stage: super::leak_str(&$plan.stage),
@@ -67,6 +168,416 @@ macro_rules! stage_driver {
             degree: $plan.degree,
         }
     };
+    (generated, $module:ident, $driver:ident, $plan:ident) => {
+        $module::$driver {
+            symbol: super::leak_str(&$plan.symbol),
+            stage: super::leak_str(&$plan.stage),
+            proof_slot: super::leak_str(&$plan.proof_slot),
+            kernel: $plan.kernel.as_deref().map(super::leak_str),
+            relation: stage_optional_relation_kind!(generated, $plan.relation.as_deref()),
+            batch: super::leak_str(&$plan.batch),
+            policy: super::leak_str(&$plan.policy),
+            round_schedule: super::leak_usize_slice(&$plan.round_schedule),
+            claim_label: super::leak_str(&$plan.claim_label),
+            round_label: super::leak_str(&$plan.round_label),
+            num_rounds: $plan.num_rounds,
+            degree: $plan.degree,
+        }
+    };
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_program_step_kind(value: &str) -> bolt_verifier_runtime::ProgramStepKind {
+    match value {
+        "transcript_squeeze" => bolt_verifier_runtime::ProgramStepKind::TranscriptSqueeze,
+        "transcript_absorb_bytes" => bolt_verifier_runtime::ProgramStepKind::TranscriptAbsorbBytes,
+        "sumcheck_driver" => bolt_verifier_runtime::ProgramStepKind::SumcheckDriver,
+        value => panic!("unsupported generated program step kind `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_transcript_squeeze_kind(value: &str) -> bolt_verifier_runtime::TranscriptSqueezeKind {
+    match value {
+        "challenge_scalar" => bolt_verifier_runtime::TranscriptSqueezeKind::ChallengeScalar,
+        "challenge_vector" => bolt_verifier_runtime::TranscriptSqueezeKind::ChallengeVector,
+        "scalar" => bolt_verifier_runtime::TranscriptSqueezeKind::Scalar,
+        value => panic!("unsupported generated transcript squeeze kind `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_claim_kind(value: &str) -> bolt_verifier_runtime::ClaimKind {
+    match value {
+        "committed" => bolt_verifier_runtime::ClaimKind::Committed,
+        "virtual" => bolt_verifier_runtime::ClaimKind::Virtual,
+        value => panic!("unsupported generated claim kind `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_relation_kind(value: &str) -> jolt_verifier::stages::jolt_relations::JoltRelationKind {
+    match value {
+        "jolt.stage1.outer.uniskip" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage1OuterUniskip
+        }
+        "jolt.stage1.outer.remaining" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage1OuterRemaining
+        }
+        "jolt.stage2.product_virtual.uniskip" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2ProductVirtualUniskip
+        }
+        "jolt.stage2.ram.read_write" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2RamReadWrite
+        }
+        "jolt.stage2.product_virtual.remainder" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2ProductVirtualRemainder
+        }
+        "jolt.stage2.instruction_lookup.claim_reduction" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2InstructionLookupClaimReduction
+        }
+        "jolt.stage2.ram.raf_evaluation" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2RamRafEvaluation
+        }
+        "jolt.stage2.ram.output_check" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2RamOutputCheck
+        }
+        "jolt.stage2.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2Batched,
+        "jolt.stage3.spartan_shift" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage3SpartanShift
+        }
+        "jolt.stage3.instruction_input" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage3InstructionInput
+        }
+        "jolt.stage3.registers_claim_reduction" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage3RegistersClaimReduction
+        }
+        "jolt.stage3.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage3Batched,
+        "jolt.stage4.registers_read_write" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage4RegistersReadWrite
+        }
+        "jolt.stage4.ram_val_check" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage4RamValCheck
+        }
+        "jolt.stage4.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage4Batched,
+        "jolt.stage5.instruction_read_raf" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage5InstructionReadRaf
+        }
+        "jolt.stage5.ram_ra_claim_reduction" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage5RamRaClaimReduction
+        }
+        "jolt.stage5.registers_val_evaluation" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage5RegistersValEvaluation
+        }
+        "jolt.stage5.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage5Batched,
+        "jolt.stage6.bytecode_read_raf" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6BytecodeReadRaf
+        }
+        "jolt.stage6.booleanity" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6Booleanity,
+        "jolt.stage6.hamming_booleanity" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6HammingBooleanity
+        }
+        "jolt.stage6.ram_ra_virtual" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6RamRaVirtual
+        }
+        "jolt.stage6.instruction_ra_virtual" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6InstructionRaVirtual
+        }
+        "jolt.stage6.inc_claim_reduction" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6IncClaimReduction
+        }
+        "jolt.stage6.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6Batched,
+        "jolt.stage7.hamming_weight_claim_reduction" => {
+            jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage7HammingWeightClaimReduction
+        }
+        "jolt.stage7.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage7Batched,
+        value => panic!("unsupported generated relation `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::expect_used,
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier field expression tag"
+)]
+fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKind {
+    match value {
+        "opening_eval" => bolt_verifier_runtime::FieldExprKind::OpeningEval,
+        "field.add" => bolt_verifier_runtime::FieldExprKind::Add,
+        "field.sub" => bolt_verifier_runtime::FieldExprKind::Sub,
+        "field.mul" => bolt_verifier_runtime::FieldExprKind::Mul,
+        "field.sum" => bolt_verifier_runtime::FieldExprKind::Sum,
+        "field.product" => bolt_verifier_runtime::FieldExprKind::Product,
+        "field.neg" => bolt_verifier_runtime::FieldExprKind::Neg,
+        value if value.starts_with("field.pow:") => {
+            let exponent = value
+                .strip_prefix("field.pow:")
+                .expect("field pow expression has prefix")
+                .parse::<usize>()
+                .expect("field pow expression has usize exponent");
+            bolt_verifier_runtime::FieldExprKind::Pow(exponent)
+        }
+        value if value.starts_with("poly.lagrange_basis_eval:") => {
+            let spec = value
+                .strip_prefix("poly.lagrange_basis_eval:")
+                .expect("lagrange expression has prefix");
+            let parts = spec.split(':').collect::<Vec<_>>();
+            assert!(parts.len() == 3, "lagrange expression has three fields");
+            bolt_verifier_runtime::FieldExprKind::LagrangeBasisEval(
+                parts[0]
+                    .parse::<i64>()
+                    .expect("lagrange domain start is i64"),
+                parts[1]
+                    .parse::<usize>()
+                    .expect("lagrange domain size is usize"),
+                parts[2].parse::<usize>().expect("lagrange index is usize"),
+            )
+        }
+        value if value.starts_with("poly.lagrange_kernel_eval:") => {
+            let spec = value
+                .strip_prefix("poly.lagrange_kernel_eval:")
+                .expect("lagrange kernel expression has prefix");
+            let parts = spec.split(':').collect::<Vec<_>>();
+            assert!(
+                parts.len() == 2,
+                "lagrange kernel expression has two fields"
+            );
+            bolt_verifier_runtime::FieldExprKind::LagrangeKernelEval(
+                parts[0]
+                    .parse::<i64>()
+                    .expect("lagrange kernel domain start is i64"),
+                parts[1]
+                    .parse::<usize>()
+                    .expect("lagrange kernel domain size is usize"),
+            )
+        }
+        value => panic!("unsupported generated field expression kind `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::expect_used,
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier scalar expression tag"
+)]
+fn generated_scalar_expr_kind(value: &str) -> bolt_verifier_runtime::ScalarExprKind {
+    match value {
+        "field_vector.sum" => bolt_verifier_runtime::ScalarExprKind::FieldVectorSum,
+        "field_vector.product" => bolt_verifier_runtime::ScalarExprKind::FieldVectorProduct,
+        value if value.starts_with("point.element:") => {
+            let index = value
+                .strip_prefix("point.element:")
+                .expect("point element expression has prefix")
+                .parse::<usize>()
+                .expect("point element index is usize");
+            bolt_verifier_runtime::ScalarExprKind::PointElement { index }
+        }
+        value if value.starts_with("field.power_strided_weighted_sum:") => {
+            let spec = value
+                .strip_prefix("field.power_strided_weighted_sum:")
+                .expect("power-strided weighted expression has prefix");
+            let parts = spec.split(':').collect::<Vec<_>>();
+            assert!(
+                parts.len() == 5,
+                "power-strided weighted expression has five fields"
+            );
+            bolt_verifier_runtime::ScalarExprKind::PowerStridedWeightedSum {
+                row_count: parts[0]
+                    .parse::<usize>()
+                    .expect("power-strided weighted row count is usize"),
+                power_stride: parts[1]
+                    .parse::<usize>()
+                    .expect("power-strided weighted power stride is usize"),
+                value_term_offsets: leak_slice(parse_usize_list(parts[2])),
+                shared_term_offsets: leak_slice(parse_usize_list(parts[3])),
+                row_term_offsets: leak_slice(parse_usize_list(parts[4])),
+            }
+        }
+        value if value.starts_with("poly.structured_eval:") => {
+            let spec = value
+                .strip_prefix("poly.structured_eval:")
+                .expect("structured polynomial expression has prefix");
+            let parts = spec.split(':').collect::<Vec<_>>();
+            assert!(
+                parts.len() == 7,
+                "structured polynomial expression has seven fields"
+            );
+            bolt_verifier_runtime::ScalarExprKind::StructuredPolynomial {
+                polynomial: generated_structured_polynomial_kind(parts[0]),
+                x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform {
+                    segment: generated_structured_polynomial_point_segment(parts[1]),
+                    length: generated_structured_polynomial_point_length(parts[2]),
+                    order: generated_structured_polynomial_point_order(parts[3]),
+                },
+                y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform {
+                    segment: generated_structured_polynomial_point_segment(parts[4]),
+                    length: generated_structured_polynomial_point_length(parts[5]),
+                    order: generated_structured_polynomial_point_order(parts[6]),
+                },
+            }
+        }
+        value => panic!("unsupported generated scalar expression kind `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::expect_used,
+    reason = "equivalence adapters fail fast when a compiler power-strided field expression is malformed"
+)]
+fn parse_usize_list(value: &str) -> Vec<usize> {
+    if value == "_" {
+        return Vec::new();
+    }
+    value
+        .split(',')
+        .map(|part| {
+            part.parse::<usize>()
+                .expect("weighted eval-family offset is usize")
+        })
+        .collect()
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_opening_equality_mode(value: &str) -> bolt_verifier_runtime::OpeningEqualityMode {
+    match value {
+        "point_and_eval" => bolt_verifier_runtime::OpeningEqualityMode::PointAndEval,
+        value => panic!("unsupported generated opening equality mode `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_structured_polynomial_kind(
+    value: &str,
+) -> bolt_verifier_runtime::StructuredPolynomialKind {
+    match value {
+        "eq" => bolt_verifier_runtime::StructuredPolynomialKind::Eq,
+        "eq_plus_one" => bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne,
+        "lt" => bolt_verifier_runtime::StructuredPolynomialKind::Lt,
+        value => panic!("unsupported generated structured polynomial `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_structured_polynomial_point_segment(
+    value: &str,
+) -> bolt_verifier_runtime::StructuredPolynomialPointSegment {
+    match value {
+        "full" => bolt_verifier_runtime::StructuredPolynomialPointSegment::Full,
+        "prefix" => bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix,
+        "suffix" => bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix,
+        value => panic!("unsupported generated structured polynomial point segment `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_structured_polynomial_point_length(
+    value: &str,
+) -> bolt_verifier_runtime::StructuredPolynomialPointLength {
+    match value {
+        "full" => bolt_verifier_runtime::StructuredPolynomialPointLength::Full,
+        "x_point" => bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint,
+        "y_point" => bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint,
+        value => panic!("unsupported generated structured polynomial point length `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_structured_polynomial_point_order(
+    value: &str,
+) -> bolt_verifier_runtime::StructuredPolynomialPointOrder {
+    match value {
+        "as_is" => bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs,
+        "reverse" => bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse,
+        value => panic!("unsupported generated structured polynomial point order `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag"
+)]
+fn generated_sumcheck_point_order(value: &str) -> bolt_verifier_runtime::SumcheckPointOrder {
+    match value {
+        "as_is" => bolt_verifier_runtime::SumcheckPointOrder::AsIs,
+        "reverse" => bolt_verifier_runtime::SumcheckPointOrder::Reverse,
+        "stage4_registers_rw" | "instruction_read_raf" | "bytecode_read_raf" => {
+            bolt_verifier_runtime::SumcheckPointOrder::RelationLocal
+        }
+        "stage6_booleanity" => bolt_verifier_runtime::SumcheckPointOrder::AsIs,
+        value => panic!("unsupported generated sumcheck point order `{value}`"),
+    }
+}
+
+macro_rules! stage_program_step_kind {
+    (kernel, $module:ident, $value:expr) => {
+        super::leak_str($value)
+    };
+    (generated, $module:ident, $value:expr) => {
+        super::generated_program_step_kind($value)
+    };
+}
+
+macro_rules! stage_transcript_squeeze_kind {
+    (kernel, $module:ident, $value:expr) => {
+        super::leak_str($value)
+    };
+    (generated, $module:ident, $value:expr) => {
+        super::generated_transcript_squeeze_kind($value)
+    };
+}
+
+macro_rules! stage_claim_kind {
+    (kernel, $module:ident, $value:expr) => {
+        super::leak_str($value)
+    };
+    (generated, $module:ident, $value:expr) => {
+        super::generated_claim_kind($value)
+    };
+}
+
+macro_rules! stage_relation_kind {
+    (kernel, $module:ident, $value:expr) => {
+        super::leak_str($value)
+    };
+    (generated, $module:ident, $value:expr) => {
+        super::generated_relation_kind($value)
+    };
+}
+
+macro_rules! stage_opening_equality_mode {
+    (kernel, $module:ident, $value:expr) => {
+        super::leak_str($value)
+    };
+    (generated, $module:ident, $value:expr) => {
+        super::generated_opening_equality_mode($value)
+    };
 }
 
 macro_rules! define_stage_adapter_impl {
@@ -87,15 +598,23 @@ macro_rules! define_stage_adapter_impl {
         $driver:ident,
         $instance_result:ident,
         $eval:ident,
-        $point_slice:ident,
-        $point_concat:ident,
         $opening_claim:ident,
         $opening_batch:ident
         $(, role = $role_field:ident)?
         $(, transcript_absorb_bytes = $absorb:ident)?
         $(, kernels = $kernel:ident)?
-        $(, point_zeros = $point_zero:ident)?
+        $(, scalar_expr = $scalar_expr:ident)?
+        $(, empty_scalar_exprs = $empty_scalar_exprs:ident)?
+        $(, generated_points = $generated_point:ident)?
+        $(, generated_points_with_zeros = $generated_point_with_zeros:ident, $generated_point_zero:ident)?
+        $(, kernel_points = $kernel_point_slice:ident, $kernel_point_concat:ident)?
+        $(, kernel_points_with_zeros = $kernel_point_slice_with_zeros:ident, $kernel_point_concat_with_zeros:ident, $kernel_point_zero:ident)?
+        $(, indexed_eval_families = $indexed_eval_families:ident)?
+        $(, empty_indexed_eval_families = $empty_indexed_eval_families:ident)?
+        $(, relation_outputs = $relation_output:ident)?
+        $(, empty_relation_outputs = $empty_relation_outputs:ident)?
         $(, opening_equalities = $opening_equality:ident)?
+        $(, empty_opening_equalities = $empty_opening_equalities:ident)?
     ) => {
         pub fn $function(program: &$compiler) -> &'static $module::$program {
             Box::leak(Box::new($module::$program {
@@ -112,7 +631,7 @@ macro_rules! define_stage_adapter_impl {
                         .steps
                         .iter()
                         .map(|plan| $module::$step {
-                            kind: super::leak_str(&plan.kind),
+                            kind: stage_program_step_kind!($mode, $module, plan.kind.as_str()),
                             symbol: super::leak_str(&plan.symbol),
                         })
                         .collect(),
@@ -124,7 +643,7 @@ macro_rules! define_stage_adapter_impl {
                         .map(|plan| $module::$squeeze {
                             symbol: super::leak_str(&plan.symbol),
                             label: super::leak_str(&plan.label),
-                            kind: super::leak_str(&plan.kind),
+                            kind: stage_transcript_squeeze_kind!($mode, $module, plan.kind.as_str()),
                             count: plan.count,
                         })
                         .collect(),
@@ -153,7 +672,7 @@ macro_rules! define_stage_adapter_impl {
                             oracle: super::leak_str(&plan.oracle),
                             domain: super::leak_str(&plan.domain),
                             point_arity: plan.point_arity,
-                            claim_kind: super::leak_str(&plan.claim_kind),
+                            claim_kind: stage_claim_kind!($mode, $module, plan.claim_kind.as_str()),
                         })
                         .collect(),
                 ),
@@ -176,6 +695,21 @@ macro_rules! define_stage_adapter_impl {
                         .collect(),
                 ),
                 $(
+                scalar_exprs: super::leak_slice(
+                    program
+                        .scalar_exprs
+                        .iter()
+                        .map(|plan| stage_scalar_expr!($mode, $module, $scalar_expr, plan))
+                        .collect(),
+                ),
+                )?
+                $(
+                scalar_exprs: {
+                    let _ = stringify!($empty_scalar_exprs);
+                    &[]
+                },
+                )?
+                $(
                 kernels: super::leak_slice(
                     program
                         .kernels
@@ -201,25 +735,14 @@ macro_rules! define_stage_adapter_impl {
                     program
                         .batches
                         .iter()
-                        .map(|plan| $module::$batch {
-                            symbol: super::leak_str(&plan.symbol),
-                            stage: super::leak_str(&plan.stage),
-                            proof_slot: super::leak_str(&plan.proof_slot),
-                            policy: super::leak_str(&plan.policy),
-                            count: plan.count,
-                            ordered_claims: stage_list!($mode, &plan.ordered_claims),
-                            claim_operands: stage_list!($mode, &plan.claim_operands),
-                            claim_label: super::leak_str(&plan.claim_label),
-                            round_label: super::leak_str(&plan.round_label),
-                            round_schedule: super::leak_usize_slice(&plan.round_schedule),
-                        })
+                        .map(|plan| stage_sumcheck_batch!($mode, $module, $batch, plan))
                         .collect(),
                 ),
                 drivers: super::leak_slice(
                     program
                         .drivers
                         .iter()
-                        .map(|plan| stage_driver!($module, $driver, plan))
+                        .map(|plan| stage_driver!($mode, $module, $driver, plan))
                         .collect(),
                 ),
                 instance_results: super::leak_slice(
@@ -230,12 +753,12 @@ macro_rules! define_stage_adapter_impl {
                             symbol: super::leak_str(&plan.symbol),
                             source: super::leak_str(&plan.source),
                             claim: super::leak_str(&plan.claim),
-                            relation: super::leak_str(&plan.relation),
+                            relation: stage_relation_kind!($mode, $module, plan.relation.as_str()),
                             index: plan.index,
                             point_arity: plan.point_arity,
                             num_rounds: plan.num_rounds,
                             round_offset: plan.round_offset,
-                            point_order: super::leak_str(&plan.point_order),
+                            point_order: stage_sumcheck_point_order!($mode, &plan.point_order),
                             degree: plan.degree,
                         })
                         .collect(),
@@ -254,23 +777,94 @@ macro_rules! define_stage_adapter_impl {
                         .collect(),
                 ),
                 $(
+                indexed_eval_families: super::leak_named_eval_family_rows(
+                    program.$indexed_eval_families()
+                ),
+                )?
+                $(
+                indexed_eval_families: {
+                    let _ = stringify!($empty_indexed_eval_families);
+                    &[]
+                },
+                )?
+                $(
+                relation_outputs: super::leak_slice(
+                    program
+                        .relation_outputs
+                        .iter()
+                        .map(|plan| $module::$relation_output {
+                            relation: super::generated_relation_kind(plan.relation_symbol()),
+                            local_scalars: super::leak_str_iter(plan.local_scalar_symbols()),
+                            expected_output: super::leak_str(plan.expected_output_symbol()),
+                        })
+                        .collect(),
+                ),
+                )?
+                $(
+                relation_outputs: {
+                    let _ = stringify!($empty_relation_outputs);
+                    &[]
+                },
+                )?
+                $(
+                point_exprs: stage_generated_point_exprs!(
+                    $module,
+                    $generated_point,
+                    program
+                ),
+                )?
+                $(
+                point_exprs: stage_generated_point_exprs!(
+                    $module,
+                    $generated_point_with_zeros,
+                    program,
+                    point_zero = $generated_point_zero
+                ),
+                )?
+                $(
+                point_slices: super::leak_slice(
+                    program
+                        .point_slices
+                        .iter()
+                        .map(|plan| $module::$kernel_point_slice {
+                            symbol: super::leak_str(&plan.symbol),
+                            source: super::leak_str(&plan.source),
+                            offset: plan.offset,
+                            length: plan.length,
+                            input: super::leak_str(&plan.input),
+                        })
+                        .collect(),
+                ),
+                point_concats: super::leak_slice(
+                    program
+                        .point_concats
+                        .iter()
+                        .map(|plan| $module::$kernel_point_concat {
+                            symbol: super::leak_str(&plan.symbol),
+                            layout: super::leak_str(&plan.layout),
+                            arity: plan.arity,
+                            inputs: super::leak_str_slice(&plan.inputs),
+                        })
+                        .collect(),
+                ),
+                )?
+                $(
                 point_zeros: super::leak_slice(
                     program
                         .point_zeros
                         .iter()
-                        .map(|plan| $module::$point_zero {
+                        .map(|plan| $module::$kernel_point_zero {
                             symbol: super::leak_str(&plan.symbol),
                             field: super::leak_str(&plan.field),
                             arity: plan.arity,
                         })
                         .collect(),
                 ),
-                )?
                 point_slices: super::leak_slice(
                     program
                         .point_slices
                         .iter()
-                        .map(|plan| $module::$point_slice {
+                        .map(|plan| $module::$kernel_point_slice_with_zeros {
                             symbol: super::leak_str(&plan.symbol),
                             source: super::leak_str(&plan.source),
                             offset: plan.offset,
@@ -283,14 +877,15 @@ macro_rules! define_stage_adapter_impl {
                     program
                         .point_concats
                         .iter()
-                        .map(|plan| $module::$point_concat {
+                        .map(|plan| $module::$kernel_point_concat_with_zeros {
                             symbol: super::leak_str(&plan.symbol),
                             layout: super::leak_str(&plan.layout),
                             arity: plan.arity,
-                            inputs: stage_list!($mode, &plan.inputs),
+                            inputs: super::leak_str_slice(&plan.inputs),
                         })
                         .collect(),
                 ),
+                )?
                 opening_claims: super::leak_slice(
                     program
                         .opening_claims
@@ -300,7 +895,7 @@ macro_rules! define_stage_adapter_impl {
                             oracle: super::leak_str(&plan.oracle),
                             domain: super::leak_str(&plan.domain),
                             point_arity: plan.point_arity,
-                            claim_kind: super::leak_str(&plan.claim_kind),
+                            claim_kind: stage_claim_kind!($mode, $module, plan.claim_kind.as_str()),
                             point_source: super::leak_str(&plan.point_source),
                             eval_source: super::leak_str(&plan.eval_source),
                         })
@@ -313,13 +908,19 @@ macro_rules! define_stage_adapter_impl {
                         .iter()
                         .map(|plan| $module::$opening_equality {
                             symbol: super::leak_str(&plan.symbol),
-                            mode: super::leak_str(&plan.mode),
+                            mode: stage_opening_equality_mode!($mode, $module, plan.mode.as_str()),
                             lhs: super::leak_str(&plan.lhs),
                             rhs: super::leak_str(&plan.rhs),
                         })
                         .collect(),
                 ),
                 )?
+                $(
+                opening_equalities: {
+                    let _ = stringify!($empty_opening_equalities);
+                    &[]
+                },
+                )?
                 opening_batches: super::leak_slice(
                     program
                         .opening_batches
@@ -330,8 +931,8 @@ macro_rules! define_stage_adapter_impl {
                             proof_slot: super::leak_str(&plan.proof_slot),
                             policy: super::leak_str(&plan.policy),
                             count: plan.count,
-                            ordered_claims: stage_list!($mode, &plan.ordered_claims),
-                            claim_operands: stage_list!($mode, &plan.claim_operands),
+                            ordered_claims: super::leak_str_slice(&plan.ordered_claims),
+                            claim_operands: super::leak_str_slice(&plan.claim_operands),
                         })
                         .collect(),
                 ),
@@ -342,7 +943,200 @@ macro_rules! define_stage_adapter_impl {
 
 macro_rules! define_stage_adapter {
     (
-        $mode:ident,
+        generated,
+        $function:ident,
+        $compiler:ty,
+        $module:ident,
+        $program:ident,
+        $params:ident,
+        $step:ident,
+        $squeeze:ident,
+        $absorb:ident,
+        $opening_input:ident,
+        $field_constant:ident,
+        $field_expr:ident,
+        $kernel:ident,
+        $claim:ident,
+        $batch:ident,
+        $driver:ident,
+        $instance_result:ident,
+        $eval:ident,
+        $point_expr:ident,
+        $point_concat:ident,
+        $opening_claim:ident,
+        $opening_equality:ident,
+        $opening_batch:ident,
+        point_zero = $point_zero:ident
+        $(, scalar_expr = $scalar_expr:ident)?
+        $(, empty_scalar_exprs = $empty_scalar_exprs:ident)?
+        $(, indexed_eval_families = $indexed_eval_families:ident)?
+        $(, empty_indexed_eval_families = $empty_indexed_eval_families:ident)?
+        $(, relation_outputs = $relation_output:ident)?
+        $(, empty_relation_outputs = $empty_relation_outputs:ident)?
+    ) => {
+        define_stage_adapter_impl!(
+            generated,
+            $function,
+            $compiler,
+            $module,
+            $program,
+            $params,
+            $step,
+            $squeeze,
+            $opening_input,
+            $field_constant,
+            $field_expr,
+            $claim,
+            $batch,
+            $driver,
+            $instance_result,
+            $eval,
+            $opening_claim,
+            $opening_batch,
+            role = role,
+            transcript_absorb_bytes = $absorb,
+            kernels = $kernel
+            $(, scalar_expr = $scalar_expr)?
+            $(, empty_scalar_exprs = $empty_scalar_exprs)?
+            ,
+            generated_points_with_zeros = $point_expr, $point_zero
+            $(, indexed_eval_families = $indexed_eval_families)?
+            $(, empty_indexed_eval_families = $empty_indexed_eval_families)?
+            $(, relation_outputs = $relation_output)?
+            $(, empty_relation_outputs = $empty_relation_outputs)?
+            ,
+            opening_equalities = $opening_equality
+        );
+    };
+    (
+        generated,
+        $function:ident,
+        $compiler:ty,
+        $module:ident,
+        $program:ident,
+        $params:ident,
+        $step:ident,
+        $squeeze:ident,
+        $absorb:ident,
+        $opening_input:ident,
+        $field_constant:ident,
+        $field_expr:ident,
+        $kernel:ident,
+        $claim:ident,
+        $batch:ident,
+        $driver:ident,
+        $instance_result:ident,
+        $eval:ident,
+        $point_expr:ident,
+        $point_concat:ident,
+        $opening_claim:ident,
+        $opening_equality:ident,
+        $opening_batch:ident
+        $(, scalar_expr = $scalar_expr:ident)?
+        $(, empty_scalar_exprs = $empty_scalar_exprs:ident)?
+        $(, indexed_eval_families = $indexed_eval_families:ident)?
+        $(, empty_indexed_eval_families = $empty_indexed_eval_families:ident)?
+        $(, relation_outputs = $relation_output:ident)?
+        $(, empty_relation_outputs = $empty_relation_outputs:ident)?
+    ) => {
+        define_stage_adapter_impl!(
+            generated,
+            $function,
+            $compiler,
+            $module,
+            $program,
+            $params,
+            $step,
+            $squeeze,
+            $opening_input,
+            $field_constant,
+            $field_expr,
+            $claim,
+            $batch,
+            $driver,
+            $instance_result,
+            $eval,
+            $opening_claim,
+            $opening_batch,
+            role = role,
+            transcript_absorb_bytes = $absorb,
+            kernels = $kernel
+            $(, scalar_expr = $scalar_expr)?
+            $(, empty_scalar_exprs = $empty_scalar_exprs)?
+            ,
+            generated_points = $point_expr
+            $(, indexed_eval_families = $indexed_eval_families)?
+            $(, empty_indexed_eval_families = $empty_indexed_eval_families)?
+            $(, relation_outputs = $relation_output)?
+            $(, empty_relation_outputs = $empty_relation_outputs)?
+            ,
+            opening_equalities = $opening_equality
+        );
+    };
+    (
+        kernel,
+        $function:ident,
+        $compiler:ty,
+        $module:ident,
+        $program:ident,
+        $params:ident,
+        $step:ident,
+        $squeeze:ident,
+        $absorb:ident,
+        $opening_input:ident,
+        $field_constant:ident,
+        $field_expr:ident,
+        $kernel:ident,
+        $claim:ident,
+        $batch:ident,
+        $driver:ident,
+        $instance_result:ident,
+        $eval:ident,
+        $point_slice:ident,
+        $point_concat:ident,
+        $opening_claim:ident,
+        $opening_equality:ident,
+        $opening_batch:ident,
+        point_zero = $point_zero:ident
+        $(, scalar_expr = $scalar_expr:ident)?
+        $(, empty_scalar_exprs = $empty_scalar_exprs:ident)?
+        $(, relation_outputs = $relation_output:ident)?
+        $(, empty_relation_outputs = $empty_relation_outputs:ident)?
+    ) => {
+        define_stage_adapter_impl!(
+            kernel,
+            $function,
+            $compiler,
+            $module,
+            $program,
+            $params,
+            $step,
+            $squeeze,
+            $opening_input,
+            $field_constant,
+            $field_expr,
+            $claim,
+            $batch,
+            $driver,
+            $instance_result,
+            $eval,
+            $opening_claim,
+            $opening_batch,
+            role = role,
+            transcript_absorb_bytes = $absorb,
+            kernels = $kernel
+            $(, scalar_expr = $scalar_expr)?
+            $(, empty_scalar_exprs = $empty_scalar_exprs)?
+            ,
+            kernel_points_with_zeros = $point_slice, $point_concat, $point_zero
+            $(, relation_outputs = $relation_output)?
+            $(, empty_relation_outputs = $empty_relation_outputs)?
+            ,
+            opening_equalities = $opening_equality
+        );
+    };
+    (
+        kernel,
         $function:ident,
         $compiler:ty,
         $module:ident,
@@ -365,10 +1159,13 @@ macro_rules! define_stage_adapter {
         $opening_claim:ident,
         $opening_equality:ident,
         $opening_batch:ident
-        $(, point_zero = $point_zero:ident)?
+        $(, scalar_expr = $scalar_expr:ident)?
+        $(, empty_scalar_exprs = $empty_scalar_exprs:ident)?
+        $(, relation_outputs = $relation_output:ident)?
+        $(, empty_relation_outputs = $empty_relation_outputs:ident)?
     ) => {
         define_stage_adapter_impl!(
-            $mode,
+            kernel,
             $function,
             $compiler,
             $module,
@@ -384,14 +1181,18 @@ macro_rules! define_stage_adapter {
             $driver,
             $instance_result,
             $eval,
-            $point_slice,
-            $point_concat,
             $opening_claim,
             $opening_batch,
             role = role,
             transcript_absorb_bytes = $absorb,
             kernels = $kernel
-            $(, point_zeros = $point_zero)?,
+            $(, scalar_expr = $scalar_expr)?
+            $(, empty_scalar_exprs = $empty_scalar_exprs)?
+            ,
+            kernel_points = $point_slice, $point_concat
+            $(, relation_outputs = $relation_output)?
+            $(, empty_relation_outputs = $empty_relation_outputs)?
+            ,
             opening_equalities = $opening_equality
         );
     };
@@ -399,7 +1200,66 @@ macro_rules! define_stage_adapter {
 
 macro_rules! define_stage_adapter_no_absorb {
     (
-        $mode:ident,
+        generated,
+        $function:ident,
+        $compiler:ty,
+        $module:ident,
+        $program:ident,
+        $params:ident,
+        $step:ident,
+        $squeeze:ident,
+        $opening_input:ident,
+        $field_constant:ident,
+        $field_expr:ident,
+        $claim:ident,
+        $batch:ident,
+        $driver:ident,
+        $instance_result:ident,
+        $eval:ident,
+        $point_expr:ident,
+        $point_concat:ident,
+        $opening_claim:ident,
+        $opening_batch:ident
+        $(, kernels = $kernel:ident)?
+        $(, scalar_expr = $scalar_expr:ident)?
+        $(, empty_scalar_exprs = $empty_scalar_exprs:ident)?
+        $(, relation_outputs = $relation_output:ident)?
+        $(, empty_relation_outputs = $empty_relation_outputs:ident)?
+        $(, opening_equalities = $opening_equality:ident)?
+        $(, empty_opening_equalities = $empty_opening_equalities:ident)?
+    ) => {
+        define_stage_adapter_impl!(
+            generated,
+            $function,
+            $compiler,
+            $module,
+            $program,
+            $params,
+            $step,
+            $squeeze,
+            $opening_input,
+            $field_constant,
+            $field_expr,
+            $claim,
+            $batch,
+            $driver,
+            $instance_result,
+            $eval,
+            $opening_claim,
+            $opening_batch
+            $(, kernels = $kernel)?
+            $(, scalar_expr = $scalar_expr)?
+            $(, empty_scalar_exprs = $empty_scalar_exprs)?
+            ,
+            generated_points = $point_expr
+            $(, relation_outputs = $relation_output)?
+            $(, empty_relation_outputs = $empty_relation_outputs)?
+            $(, opening_equalities = $opening_equality)?
+            $(, empty_opening_equalities = $empty_opening_equalities)?
+        );
+    };
+    (
+        kernel,
         $function:ident,
         $compiler:ty,
         $module:ident,
@@ -420,10 +1280,15 @@ macro_rules! define_stage_adapter_no_absorb {
         $opening_claim:ident,
         $opening_batch:ident
         $(, kernels = $kernel:ident)?
+        $(, scalar_expr = $scalar_expr:ident)?
+        $(, empty_scalar_exprs = $empty_scalar_exprs:ident)?
+        $(, relation_outputs = $relation_output:ident)?
+        $(, empty_relation_outputs = $empty_relation_outputs:ident)?
         $(, opening_equalities = $opening_equality:ident)?
+        $(, empty_opening_equalities = $empty_opening_equalities:ident)?
     ) => {
         define_stage_adapter_impl!(
-            $mode,
+            kernel,
             $function,
             $compiler,
             $module,
@@ -439,12 +1304,17 @@ macro_rules! define_stage_adapter_no_absorb {
             $driver,
             $instance_result,
             $eval,
-            $point_slice,
-            $point_concat,
             $opening_claim,
             $opening_batch
             $(, kernels = $kernel)?
+            $(, scalar_expr = $scalar_expr)?
+            $(, empty_scalar_exprs = $empty_scalar_exprs)?
+            ,
+            kernel_points = $point_slice, $point_concat
+            $(, relation_outputs = $relation_output)?
+            $(, empty_relation_outputs = $empty_relation_outputs)?
             $(, opening_equalities = $opening_equality)?
+            $(, empty_opening_equalities = $empty_opening_equalities)?
         );
     };
 }
@@ -481,7 +1351,7 @@ macro_rules! define_stage1_adapter {
                         .map(|plan| $module::$squeeze {
                             symbol: super::leak_str(&plan.symbol),
                             label: super::leak_str(&plan.label),
-                            kind: super::leak_str(&plan.kind),
+                            kind: stage_transcript_squeeze_kind!($mode, $module, plan.kind.as_str()),
                             count: plan.count,
                         })
                         .collect(),
@@ -512,25 +1382,14 @@ macro_rules! define_stage1_adapter {
                     program
                         .batches
                         .iter()
-                        .map(|plan| $module::$batch {
-                            symbol: super::leak_str(&plan.symbol),
-                            stage: super::leak_str(&plan.stage),
-                            proof_slot: super::leak_str(&plan.proof_slot),
-                            policy: super::leak_str(&plan.policy),
-                            count: plan.count,
-                            ordered_claims: stage_list!($mode, &plan.ordered_claims),
-                            claim_operands: stage_list!($mode, &plan.claim_operands),
-                            claim_label: super::leak_str(&plan.claim_label),
-                            round_label: super::leak_str(&plan.round_label),
-                            round_schedule: super::leak_usize_slice(&plan.round_schedule),
-                        })
+                        .map(|plan| stage_sumcheck_batch!($mode, $module, $batch, plan))
                         .collect(),
                 ),
                 drivers: super::leak_slice(
                     program
                         .drivers
                         .iter()
-                        .map(|plan| stage_driver!($module, $driver, plan))
+                        .map(|plan| stage_driver!($mode, $module, $driver, plan))
                         .collect(),
                 ),
                 instance_results: super::leak_slice(
@@ -541,12 +1400,12 @@ macro_rules! define_stage1_adapter {
                             symbol: super::leak_str(&plan.symbol),
                             source: super::leak_str(&plan.source),
                             claim: super::leak_str(&plan.claim),
-                            relation: super::leak_str(&plan.relation),
+                            relation: stage_relation_kind!($mode, $module, plan.relation.as_str()),
                             index: plan.index,
                             point_arity: plan.point_arity,
                             num_rounds: plan.num_rounds,
                             round_offset: plan.round_offset,
-                            point_order: super::leak_str(&plan.point_order),
+                            point_order: stage_sumcheck_point_order!($mode, &plan.point_order),
                             degree: plan.degree,
                         })
                         .collect(),
@@ -573,7 +1432,7 @@ macro_rules! define_stage1_adapter {
                             oracle: super::leak_str(&plan.oracle),
                             domain: super::leak_str(&plan.domain),
                             point_arity: plan.point_arity,
-                            claim_kind: super::leak_str(&plan.claim_kind),
+                            claim_kind: stage_claim_kind!($mode, $module, plan.claim_kind.as_str()),
                             point_source: super::leak_str(&plan.point_source),
                             eval_source: super::leak_str(&plan.eval_source),
                         })
@@ -589,8 +1448,8 @@ macro_rules! define_stage1_adapter {
                             proof_slot: super::leak_str(&plan.proof_slot),
                             policy: super::leak_str(&plan.policy),
                             count: plan.count,
-                            ordered_claims: stage_list!($mode, &plan.ordered_claims),
-                            claim_operands: stage_list!($mode, &plan.claim_operands),
+                            ordered_claims: super::leak_str_slice(&plan.ordered_claims),
+                            claim_operands: super::leak_str_slice(&plan.claim_operands),
                         })
                         .collect(),
                 ),
@@ -638,90 +1497,320 @@ use bolt::Role;
 use jolt_prover::stages::stage8 as generated_prover_stage8;
 use jolt_verifier::stages::stage8 as generated_stage8;
 
-macro_rules! define_stage8_adapter {
-    ($function:ident, $module:ident) => {
-        pub(crate) fn $function(
-            program: &CompilerStage8CpuProgram,
-        ) -> &'static $module::Stage8EvaluationProgramPlan {
-            let evaluation_point_source = program
-                .opening_inputs
-                .iter()
-                .find(|input| input.symbol == "stage8.evaluation.point_source")
-                .expect("stage8 evaluation point source exists");
-            Box::leak(Box::new($module::Stage8EvaluationProgramPlan {
-                role: role_name(&program.role),
-                function: leak_str(&program.function),
-                params: $module::Stage8Params {
-                    field: leak_str(&program.params.field),
-                    pcs: leak_str(&program.params.pcs),
-                    transcript: leak_str(&program.params.transcript),
-                },
-                evaluation_point_source: $module::Stage8OpeningInputPlan {
-                    symbol: leak_str(&evaluation_point_source.symbol),
-                    source_stage: leak_str(&evaluation_point_source.source_stage),
-                    source_claim: leak_str(&evaluation_point_source.source_claim),
-                    oracle: leak_str(&evaluation_point_source.oracle),
-                    domain: leak_str(&evaluation_point_source.domain),
-                    point_arity: evaluation_point_source.point_arity,
-                    claim_kind: leak_str(&evaluation_point_source.claim_kind),
-                },
-                opening_inputs: leak_slice(
-                    program
-                        .opening_inputs
-                        .iter()
-                        .map(|plan| $module::Stage8OpeningInputPlan {
-                            symbol: leak_str(&plan.symbol),
-                            source_stage: leak_str(&plan.source_stage),
-                            source_claim: leak_str(&plan.source_claim),
-                            oracle: leak_str(&plan.oracle),
-                            domain: leak_str(&plan.domain),
-                            point_arity: plan.point_arity,
-                            claim_kind: leak_str(&plan.claim_kind),
-                        })
-                        .collect(),
-                ),
-                opening_claims: leak_slice(
-                    program
-                        .opening_claims
-                        .iter()
-                        .map(|plan| $module::Stage8OpeningClaimPlan {
-                            symbol: leak_str(&plan.symbol),
-                            oracle: leak_str(&plan.oracle),
-                            family: leak_str(&plan.family),
-                            domain: leak_str(&plan.domain),
-                            point_arity: plan.point_arity,
-                            point_source: leak_str(&plan.point_source),
-                            eval_source: leak_str(&plan.eval_source),
-                            source_stage: leak_str(&plan.source_stage),
-                            source_claim: leak_str(&plan.source_claim),
-                        })
-                        .collect(),
-                ),
-                opening_batch: $module::Stage8OpeningBatchPlan {
-                    symbol: leak_str(&program.opening_batches[0].symbol),
-                    proof_slot: leak_str(&program.opening_batches[0].proof_slot),
-                    policy: leak_str(&program.opening_batches[0].policy),
-                    count: program.opening_batches[0].count,
-                    ordered_claims: leak_str_slice(&program.opening_batches[0].ordered_claims),
-                },
-                pcs_proof: $module::Stage8PcsProofPlan {
-                    symbol: leak_str(&program.pcs_proofs[0].symbol),
-                    mode: leak_str(&program.pcs_proofs[0].mode),
-                    pcs: leak_str(&program.pcs_proofs[0].pcs),
-                    proof_slot: leak_str(&program.pcs_proofs[0].proof_slot),
-                    transcript_label: leak_str(&program.pcs_proofs[0].transcript_label),
-                    batch: leak_str(&program.pcs_proofs[0].batch),
-                },
-            }))
-        }
-    };
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag"
+)]
+fn generated_prover_stage8_source_stage(value: &str) -> generated_prover_stage8::Stage8SourceStage {
+    match value {
+        "stage6" => generated_prover_stage8::Stage8SourceStage::Stage6,
+        "stage7" => generated_prover_stage8::Stage8SourceStage::Stage7,
+        value => panic!("unsupported Stage 8 source stage `{value}`"),
+    }
 }
 
-define_stage8_adapter!(
-    leak_generated_stage8_prover_program,
-    generated_prover_stage8
-);
-define_stage8_adapter!(leak_generated_stage8_verifier_program, generated_stage8);
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag"
+)]
+fn generated_stage8_source_stage(value: &str) -> generated_stage8::Stage8SourceStage {
+    match value {
+        "stage6" => generated_stage8::Stage8SourceStage::Stage6,
+        "stage7" => generated_stage8::Stage8SourceStage::Stage7,
+        value => panic!("unsupported Stage 8 source stage `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag"
+)]
+fn generated_prover_stage8_claim_kind(value: &str) -> generated_prover_stage8::Stage8ClaimKind {
+    match value {
+        "committed" => generated_prover_stage8::Stage8ClaimKind::Committed,
+        "virtual" => generated_prover_stage8::Stage8ClaimKind::Virtual,
+        value => panic!("unsupported Stage 8 claim kind `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag"
+)]
+fn generated_stage8_claim_kind(value: &str) -> generated_stage8::Stage8ClaimKind {
+    match value {
+        "committed" => generated_stage8::Stage8ClaimKind::Committed,
+        "virtual" => generated_stage8::Stage8ClaimKind::Virtual,
+        value => panic!("unsupported Stage 8 claim kind `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag"
+)]
+fn generated_prover_stage8_pcs_proof_mode(
+    value: &str,
+) -> generated_prover_stage8::Stage8PcsProofMode {
+    match value {
+        "open" => generated_prover_stage8::Stage8PcsProofMode::Open,
+        "verify" => generated_prover_stage8::Stage8PcsProofMode::Verify,
+        value => panic!("unsupported Stage 8 PCS proof mode `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::panic,
+    reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag"
+)]
+fn generated_stage8_pcs_proof_mode(value: &str) -> generated_stage8::Stage8PcsProofMode {
+    match value {
+        "open" => generated_stage8::Stage8PcsProofMode::Open,
+        "verify" => generated_stage8::Stage8PcsProofMode::Verify,
+        value => panic!("unsupported Stage 8 PCS proof mode `{value}`"),
+    }
+}
+
+#[expect(
+    clippy::expect_used,
+    reason = "Stage 8 adapters consume compiler-validated plans and fail fast if required generated plan rows are missing"
+)]
+fn stage8_evaluation_point_source_index(program: &CompilerStage8CpuProgram) -> usize {
+    program
+        .opening_inputs
+        .iter()
+        .position(|input| input.symbol == "stage8.evaluation.point_source")
+        .expect("stage8 evaluation point source exists")
+}
+
+#[expect(
+    clippy::expect_used,
+    reason = "Stage 8 adapters consume compiler-validated plans and fail fast if required generated plan rows are missing"
+)]
+fn stage8_ordered_claim_indices(program: &CompilerStage8CpuProgram) -> Vec<usize> {
+    let claim_index_by_symbol = program
+        .opening_claims
+        .iter()
+        .enumerate()
+        .map(|(index, claim)| (claim.symbol.as_str(), index))
+        .collect::<std::collections::BTreeMap<_, _>>();
+    program
+        .opening_batches
+        .first()
+        .expect("stage8 opening batch exists")
+        .ordered_claims
+        .iter()
+        .map(|symbol| {
+            *claim_index_by_symbol
+                .get(symbol.as_str())
+                .expect("stage8 opening batch claim exists")
+        })
+        .collect()
+}
+
+#[expect(
+    clippy::expect_used,
+    reason = "Stage 8 adapters consume compiler-validated plans and fail fast if required generated plan rows are missing"
+)]
+pub(crate) fn leak_generated_stage8_prover_program(
+    program: &CompilerStage8CpuProgram,
+) -> &'static generated_prover_stage8::Stage8EvaluationProgramPlan {
+    let evaluation_point_source_index = stage8_evaluation_point_source_index(program);
+    let ordered_claim_indices = stage8_ordered_claim_indices(program);
+    let opening_inputs = leak_slice(
+        program
+            .opening_inputs
+            .iter()
+            .map(|plan| generated_prover_stage8::Stage8OpeningInputPlan {
+                symbol: generated_prover_stage8::Stage8OpeningInputSymbol::new(leak_str(
+                    &plan.symbol,
+                )),
+                source_stage: generated_prover_stage8_source_stage(plan.source_stage.as_str()),
+                source_claim: generated_prover_stage8::Stage8SourceClaim::new(leak_str(
+                    &plan.source_claim,
+                )),
+                oracle: leak_str(&plan.oracle),
+                domain: leak_str(&plan.domain),
+                point_arity: plan.point_arity,
+                claim_kind: generated_prover_stage8_claim_kind(plan.claim_kind.as_str()),
+            })
+            .collect(),
+    );
+    let opening_claims = leak_slice(
+        program
+            .opening_claims
+            .iter()
+            .map(|plan| generated_prover_stage8::Stage8OpeningClaimPlan {
+                symbol: generated_prover_stage8::Stage8OpeningClaimSymbol::new(leak_str(
+                    &plan.symbol,
+                )),
+                oracle: leak_str(&plan.oracle),
+                family: leak_str(&plan.family),
+                domain: leak_str(&plan.domain),
+                point_arity: plan.point_arity,
+                point_source: generated_prover_stage8::Stage8OpeningInputSymbol::new(leak_str(
+                    &plan.point_source,
+                )),
+                eval_source: generated_prover_stage8::Stage8OpeningInputSymbol::new(leak_str(
+                    &plan.eval_source,
+                )),
+                source_stage: generated_prover_stage8_source_stage(plan.source_stage.as_str()),
+                source_claim: generated_prover_stage8::Stage8SourceClaim::new(leak_str(
+                    &plan.source_claim,
+                )),
+            })
+            .collect(),
+    );
+    let evaluation_point_source = *opening_inputs
+        .get(evaluation_point_source_index)
+        .expect("stage8 evaluation point source exists");
+    let ordered_claims = leak_slice(
+        ordered_claim_indices
+            .iter()
+            .map(|index| {
+                *opening_claims
+                    .get(*index)
+                    .expect("stage8 opening batch claim exists")
+            })
+            .collect(),
+    );
+    let opening_batch = program
+        .opening_batches
+        .first()
+        .expect("stage8 opening batch exists");
+    let pcs_proof = program.pcs_proofs.first().expect("stage8 PCS proof exists");
+    Box::leak(Box::new(
+        generated_prover_stage8::Stage8EvaluationProgramPlan {
+            role: role_name(&program.role),
+            function: leak_str(&program.function),
+            params: generated_prover_stage8::Stage8Params {
+                field: leak_str(&program.params.field),
+                pcs: leak_str(&program.params.pcs),
+                transcript: leak_str(&program.params.transcript),
+            },
+            evaluation_point_source,
+            opening_inputs,
+            opening_claims,
+            opening_batch: generated_prover_stage8::Stage8OpeningBatchPlan {
+                symbol: generated_prover_stage8::Stage8OpeningBatchSymbol::new(leak_str(
+                    &opening_batch.symbol,
+                )),
+                proof_slot: leak_str(&opening_batch.proof_slot),
+                policy: leak_str(&opening_batch.policy),
+                count: opening_batch.count,
+                ordered_claims,
+            },
+            pcs_proof: generated_prover_stage8::Stage8PcsProofPlan {
+                symbol: leak_str(&pcs_proof.symbol),
+                mode: generated_prover_stage8_pcs_proof_mode(pcs_proof.mode.as_str()),
+                pcs: leak_str(&pcs_proof.pcs),
+                proof_slot: leak_str(&pcs_proof.proof_slot),
+                transcript_label: leak_str(&pcs_proof.transcript_label),
+                batch: generated_prover_stage8::Stage8OpeningBatchSymbol::new(leak_str(
+                    &pcs_proof.batch,
+                )),
+            },
+        },
+    ))
+}
+
+#[expect(
+    clippy::expect_used,
+    reason = "Stage 8 adapters consume compiler-validated plans and fail fast if required generated plan rows are missing"
+)]
+pub(crate) fn leak_generated_stage8_verifier_program(
+    program: &CompilerStage8CpuProgram,
+) -> &'static generated_stage8::Stage8EvaluationProgramPlan {
+    let evaluation_point_source_index = stage8_evaluation_point_source_index(program);
+    let ordered_claim_indices = stage8_ordered_claim_indices(program);
+    let opening_inputs = leak_slice(
+        program
+            .opening_inputs
+            .iter()
+            .map(|plan| generated_stage8::Stage8OpeningInputPlan {
+                symbol: generated_stage8::Stage8OpeningInputSymbol::new(leak_str(&plan.symbol)),
+                source_stage: generated_stage8_source_stage(plan.source_stage.as_str()),
+                source_claim: generated_stage8::Stage8SourceClaim::new(leak_str(
+                    &plan.source_claim,
+                )),
+                oracle: leak_str(&plan.oracle),
+                domain: leak_str(&plan.domain),
+                point_arity: plan.point_arity,
+                claim_kind: generated_stage8_claim_kind(plan.claim_kind.as_str()),
+            })
+            .collect(),
+    );
+    let opening_claims = leak_slice(
+        program
+            .opening_claims
+            .iter()
+            .map(|plan| generated_stage8::Stage8OpeningClaimPlan {
+                symbol: generated_stage8::Stage8OpeningClaimSymbol::new(leak_str(&plan.symbol)),
+                oracle: leak_str(&plan.oracle),
+                family: leak_str(&plan.family),
+                domain: leak_str(&plan.domain),
+                point_arity: plan.point_arity,
+                point_source: generated_stage8::Stage8OpeningInputSymbol::new(leak_str(
+                    &plan.point_source,
+                )),
+                eval_source: generated_stage8::Stage8OpeningInputSymbol::new(leak_str(
+                    &plan.eval_source,
+                )),
+                source_stage: generated_stage8_source_stage(plan.source_stage.as_str()),
+                source_claim: generated_stage8::Stage8SourceClaim::new(leak_str(
+                    &plan.source_claim,
+                )),
+            })
+            .collect(),
+    );
+    let evaluation_point_source = *opening_inputs
+        .get(evaluation_point_source_index)
+        .expect("stage8 evaluation point source exists");
+    let ordered_claims = leak_slice(
+        ordered_claim_indices
+            .iter()
+            .map(|index| {
+                *opening_claims
+                    .get(*index)
+                    .expect("stage8 opening batch claim exists")
+            })
+            .collect(),
+    );
+    let opening_batch = program
+        .opening_batches
+        .first()
+        .expect("stage8 opening batch exists");
+    let pcs_proof = program.pcs_proofs.first().expect("stage8 PCS proof exists");
+    Box::leak(Box::new(generated_stage8::Stage8EvaluationProgramPlan {
+        role: role_name(&program.role),
+        function: leak_str(&program.function),
+        params: generated_stage8::Stage8Params {
+            field: leak_str(&program.params.field),
+            pcs: leak_str(&program.params.pcs),
+            transcript: leak_str(&program.params.transcript),
+        },
+        evaluation_point_source,
+        opening_inputs,
+        opening_claims,
+        opening_batch: generated_stage8::Stage8OpeningBatchPlan {
+            symbol: generated_stage8::Stage8OpeningBatchSymbol::new(leak_str(
+                &opening_batch.symbol,
+            )),
+            proof_slot: leak_str(&opening_batch.proof_slot),
+            policy: leak_str(&opening_batch.policy),
+            count: opening_batch.count,
+            ordered_claims,
+        },
+        pcs_proof: generated_stage8::Stage8PcsProofPlan {
+            symbol: leak_str(&pcs_proof.symbol),
+            mode: generated_stage8_pcs_proof_mode(pcs_proof.mode.as_str()),
+            pcs: leak_str(&pcs_proof.pcs),
+            proof_slot: leak_str(&pcs_proof.proof_slot),
+            transcript_label: leak_str(&pcs_proof.transcript_label),
+            batch: generated_stage8::Stage8OpeningBatchSymbol::new(leak_str(&pcs_proof.batch)),
+        },
+    }))
+}
 
 fn role_name(role: &Role) -> &'static str {
     match role {
@@ -735,15 +1824,30 @@ fn leak_str(value: &str) -> &'static str {
 }
 
 fn leak_str_slice(values: &[String]) -> &'static [&'static str] {
+    leak_str_iter(values.iter())
+}
+
+fn leak_str_iter<'a>(values: impl IntoIterator<Item = &'a String>) -> &'static [&'static str] {
     let leaked = values
-        .iter()
+        .into_iter()
         .map(|value| leak_str(value))
         .collect::<Vec<_>>();
     Box::leak(leaked.into_boxed_slice())
 }
 
-fn leak_symbol_list(values: &[String]) -> &'static str {
-    leak_str(&values.join("|"))
+fn leak_named_eval_family_rows<'a>(
+    rows: impl IntoIterator<Item = (&'a str, &'a [String])>,
+) -> &'static [bolt_verifier_runtime::NamedEvalFamilyPlan] {
+    leak_slice(
+        rows.into_iter()
+            .map(
+                |(symbol, evals)| bolt_verifier_runtime::NamedEvalFamilyPlan {
+                    symbol: leak_str(symbol),
+                    evals: leak_str_slice(evals),
+                },
+            )
+            .collect(),
+    )
 }
 
 fn leak_usize_slice(values: &[usize]) -> &'static [usize] {
diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs
index 517e934a68..6213a95a30 100644
--- a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs
+++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs
@@ -18,8 +18,11 @@ define_stage_adapter_no_absorb!(
     Stage2SumcheckDriverPlan,
     Stage2SumcheckInstanceResultPlan,
     Stage2SumcheckEvalPlan,
-    Stage2PointSlicePlan,
-    Stage2PointConcatPlan,
+    Stage2PointExprPlan,
+    Stage2PointExprPlan,
     Stage2OpeningClaimPlan,
-    Stage2OpeningBatchPlan
+    Stage2OpeningBatchPlan,
+    scalar_expr = Stage2ScalarExprPlan,
+    relation_outputs = Stage2RelationOutputPlan,
+    empty_opening_equalities = Stage2OpeningClaimEqualityPlan
 );
diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs
index 5dcb77bf10..8b424386f3 100644
--- a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs
+++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs
@@ -18,9 +18,11 @@ define_stage_adapter_no_absorb!(
     Stage3SumcheckDriverPlan,
     Stage3SumcheckInstanceResultPlan,
     Stage3SumcheckEvalPlan,
-    Stage3PointSlicePlan,
-    Stage3PointConcatPlan,
+    Stage3PointExprPlan,
+    Stage3PointExprPlan,
     Stage3OpeningClaimPlan,
     Stage3OpeningBatchPlan,
+    scalar_expr = Stage3ScalarExprPlan,
+    relation_outputs = Stage3RelationOutputPlan,
     opening_equalities = Stage3OpeningClaimEqualityPlan
 );
diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs
index a9340f0907..80e727fde6 100644
--- a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs
+++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs
@@ -20,9 +20,12 @@ define_stage_adapter!(
     Stage4SumcheckDriverPlan,
     Stage4SumcheckInstanceResultPlan,
     Stage4SumcheckEvalPlan,
-    Stage4PointSlicePlan,
-    Stage4PointConcatPlan,
+    Stage4PointExprPlan,
+    Stage4PointExprPlan,
     Stage4OpeningClaimPlan,
     Stage4OpeningClaimEqualityPlan,
-    Stage4OpeningBatchPlan
+    Stage4OpeningBatchPlan,
+    scalar_expr = Stage4ScalarExprPlan,
+    empty_indexed_eval_families = empty_indexed_eval_families,
+    relation_outputs = Stage4RelationOutputPlan
 );
diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs
index 0033acb89a..c04eb8ac50 100644
--- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs
+++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs
@@ -3,10 +3,10 @@ use jolt_verifier::stages::stage5 as generated_stage5;
 
 define_stage_adapter!(
     generated,
-    leak_generated_stage5_verifier_program,
+    leak_generated_stage5_base_verifier_program,
     CompilerStage5CpuProgram,
     generated_stage5,
-    Stage5VerifierProgramPlan,
+    Stage5CpuProgramPlan,
     Stage5Params,
     Stage5ProgramStepPlan,
     Stage5TranscriptSqueezePlan,
@@ -20,9 +20,21 @@ define_stage_adapter!(
     Stage5SumcheckDriverPlan,
     Stage5SumcheckInstanceResultPlan,
     Stage5SumcheckEvalPlan,
-    Stage5PointSlicePlan,
-    Stage5PointConcatPlan,
+    Stage5PointExprPlan,
+    Stage5PointExprPlan,
     Stage5OpeningClaimPlan,
     Stage5OpeningClaimEqualityPlan,
-    Stage5OpeningBatchPlan
+    Stage5OpeningBatchPlan,
+    scalar_expr = Stage5ScalarExprPlan,
+    indexed_eval_families = indexed_eval_family_rows,
+    relation_outputs = Stage5RelationOutputPlan
 );
+
+pub fn leak_generated_stage5_verifier_program(
+    program: &CompilerStage5CpuProgram,
+) -> &'static generated_stage5::Stage5VerifierProgramPlan {
+    Box::leak(Box::new(generated_stage5::Stage5VerifierProgramPlan {
+        base: *leak_generated_stage5_base_verifier_program(program),
+        instruction_read_raf_plan: generated_stage5::STAGE5_INSTRUCTION_READ_RAF_PLAN,
+    }))
+}
diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs
index 76072dd614..46a57c84b5 100644
--- a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs
+++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs
@@ -3,10 +3,10 @@ use jolt_verifier::stages::stage6 as generated_stage6;
 
 define_stage_adapter!(
     generated,
-    leak_generated_stage6_verifier_program,
+    leak_generated_stage6_base_verifier_program,
     CompilerStage6CpuProgram,
     generated_stage6,
-    Stage6VerifierProgramPlan,
+    Stage6CpuProgramPlan,
     Stage6Params,
     Stage6ProgramStepPlan,
     Stage6TranscriptSqueezePlan,
@@ -20,10 +20,22 @@ define_stage_adapter!(
     Stage6SumcheckDriverPlan,
     Stage6SumcheckInstanceResultPlan,
     Stage6SumcheckEvalPlan,
-    Stage6PointSlicePlan,
-    Stage6PointConcatPlan,
+    Stage6PointExprPlan,
+    Stage6PointExprPlan,
     Stage6OpeningClaimPlan,
     Stage6OpeningClaimEqualityPlan,
     Stage6OpeningBatchPlan,
-    point_zero = Stage6PointZeroPlan
+    point_zero = Stage6PointExprPlan,
+    scalar_expr = Stage6ScalarExprPlan,
+    indexed_eval_families = indexed_eval_family_rows,
+    relation_outputs = Stage6RelationOutputPlan
 );
+
+pub fn leak_generated_stage6_verifier_program(
+    program: &CompilerStage6CpuProgram,
+) -> &'static generated_stage6::Stage6VerifierProgramPlan {
+    Box::leak(Box::new(generated_stage6::Stage6VerifierProgramPlan {
+        base: *leak_generated_stage6_base_verifier_program(program),
+        bytecode_plan: generated_stage6::STAGE6_BYTECODE_PLAN,
+    }))
+}
diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs
index 457ac30812..3066e45cf4 100644
--- a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs
+++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs
@@ -20,10 +20,13 @@ define_stage_adapter!(
     Stage7SumcheckDriverPlan,
     Stage7SumcheckInstanceResultPlan,
     Stage7SumcheckEvalPlan,
-    Stage7PointSlicePlan,
-    Stage7PointConcatPlan,
+    Stage7PointExprPlan,
+    Stage7PointExprPlan,
     Stage7OpeningClaimPlan,
     Stage7OpeningClaimEqualityPlan,
     Stage7OpeningBatchPlan,
-    point_zero = Stage7PointZeroPlan
+    point_zero = Stage7PointExprPlan,
+    scalar_expr = Stage7ScalarExprPlan,
+    empty_indexed_eval_families = empty_indexed_eval_families,
+    relation_outputs = Stage7RelationOutputPlan
 );
diff --git a/crates/jolt-equivalence/src/tamper.rs b/crates/jolt-equivalence/src/tamper.rs
index aeceeb6db6..49c28f2d78 100644
--- a/crates/jolt-equivalence/src/tamper.rs
+++ b/crates/jolt-equivalence/src/tamper.rs
@@ -307,7 +307,7 @@ pub(crate) fn assert_monolithic_jolt_tamper_rejected(input: MonolithicJoltTamper
         .len();
     let tampered_stage7_openings = tampered_opening_input_suffix_point(
         input.inputs.stage7_openings,
-        stage8_source_symbol,
+        stage8_source_symbol.as_str(),
         stage7_address_prefix_len,
     );
     let mut tampered_stage7_opening_inputs = input.inputs;
diff --git a/crates/jolt-equivalence/tests/bolt_commitment.rs b/crates/jolt-equivalence/tests/bolt_commitment.rs
index 21e0bc308e..8f6a4824f3 100644
--- a/crates/jolt-equivalence/tests/bolt_commitment.rs
+++ b/crates/jolt-equivalence/tests/bolt_commitment.rs
@@ -312,7 +312,6 @@ fn bolt_stage2_batched_real_muldiv_self_parity() {
 }
 
 #[test]
-#[ignore = "Stage 5+ instruction-read-RAF parity needs the follow-up generated kernel rewrite"]
 fn bolt_stage3_batched_real_muldiv_self_parity() {
     let _ = assert_bolt_full_real_trace_self_parity(core_muldiv_commitment_fixture(), false);
 }
diff --git a/crates/jolt-equivalence/tests/generated_role_crates.rs b/crates/jolt-equivalence/tests/generated_role_crates.rs
index 69237f6eab..30ec58cd85 100644
--- a/crates/jolt-equivalence/tests/generated_role_crates.rs
+++ b/crates/jolt-equivalence/tests/generated_role_crates.rs
@@ -77,11 +77,11 @@ fn generated_role_crates_expose_matching_stage_prefix() {
         .is_empty());
     assert_eq!(
         jolt_prover::stages::stage8::STAGE8_PROGRAM.pcs_proof.mode,
-        "open"
+        jolt_prover::stages::stage8::Stage8PcsProofMode::Open
     );
     assert_eq!(
         jolt_verifier::stages::stage8::STAGE8_PROGRAM.pcs_proof.mode,
-        "verify"
+        jolt_verifier::stages::stage8::Stage8PcsProofMode::Verify
     );
     let _proof = jolt_verifier::JoltProof {
         commitments: Vec::new(),
diff --git a/crates/jolt-poly/src/eq.rs b/crates/jolt-poly/src/eq.rs
index 206daec033..939bf32a61 100644
--- a/crates/jolt-poly/src/eq.rs
+++ b/crates/jolt-poly/src/eq.rs
@@ -139,6 +139,49 @@ impl<F: Field> EqPolynomial<F> {
             .fold(F::one(), |acc, v| acc * v)
     }
 
+    /// Checked version of [`Self::mle`].
+    ///
+    /// Returns `None` when the two points do not have the same arity.
+    pub fn try_mle<C>(x: &[C], y: &[C]) -> Option<F>
+    where
+        C: Copy + Send + Sync + Into<F>,
+        F: Mul<C, Output = F> + SubAssign<F>,
+    {
+        if x.len() != y.len() {
+            return None;
+        }
+        Some(Self::mle(x, y))
+    }
+
+    /// Evaluates `eq(point, index_bits)` where `index_bits` is the big-endian
+    /// Boolean vector encoded by `index`.
+    ///
+    /// Returns `None` if `point` is too large to address with `usize`, or if
+    /// `index` is outside the Boolean hypercube for `point.len()` variables.
+    pub fn try_mle_at_boolean_index<C>(index: usize, point: &[C]) -> Option<F>
+    where
+        C: Copy + Into<F>,
+    {
+        let count = 1usize.checked_shl(point.len() as u32)?;
+        if index >= count {
+            return None;
+        }
+        Some(
+            point
+                .iter()
+                .enumerate()
+                .map(|(bit, value)| {
+                    let value = (*value).into();
+                    if (index >> (point.len() - 1 - bit)) & 1 == 1 {
+                        value
+                    } else {
+                        F::one() - value
+                    }
+                })
+                .product(),
+        )
+    }
+
     /// Computes `eq(r, 0) = Π_i (1 - r_i)`, selecting the all-zeros vertex.
     pub fn zero_selector<C>(r: &[C]) -> F
     where
@@ -391,6 +434,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn try_mle_at_boolean_index_selects_entry() {
+        let mut rng = ChaCha20Rng::seed_from_u64(101);
+        let n = 4;
+        let point: Vec<Fr> = (0..n).map(|_| Fr::random(&mut rng)).collect();
+        let table = EqPolynomial::new(point.clone()).evaluations();
+
+        for (index, &entry) in table.iter().enumerate() {
+            assert_eq!(
+                EqPolynomial::<Fr>::try_mle_at_boolean_index(index, &point),
+                Some(entry)
+            );
+        }
+        assert_eq!(
+            EqPolynomial::<Fr>::try_mle_at_boolean_index(table.len(), &point),
+            None
+        );
+    }
+
     #[test]
     fn evaluations_matches_evaluate_pointwise() {
         let mut rng = ChaCha20Rng::seed_from_u64(7);
@@ -580,6 +642,15 @@ mod tests {
         assert_eq!(via_instance, via_static);
     }
 
+    #[test]
+    fn try_mle_rejects_dimension_mismatch() {
+        let x = [Fr::one(), Fr::zero()];
+        let y = [Fr::one()];
+
+        assert_eq!(EqPolynomial::<Fr>::try_mle(&x, &x), Some(Fr::one()));
+        assert_eq!(EqPolynomial::<Fr>::try_mle(&x, &y), None);
+    }
+
     #[test]
     fn zero_selector() {
         let mut rng = ChaCha20Rng::seed_from_u64(405);
diff --git a/crates/jolt-poly/src/eq_plus_one.rs b/crates/jolt-poly/src/eq_plus_one.rs
index 371486d1fc..2605196733 100644
--- a/crates/jolt-poly/src/eq_plus_one.rs
+++ b/crates/jolt-poly/src/eq_plus_one.rs
@@ -56,6 +56,16 @@ impl<F: Field> EqPlusOnePolynomial<F> {
             .sum()
     }
 
+    /// Checked version of [`Self::evaluate`].
+    ///
+    /// Returns `None` when `y` does not have the same arity as the fixed point.
+    pub fn try_evaluate(&self, y: &[F]) -> Option<F> {
+        if y.len() != self.point.len() {
+            return None;
+        }
+        Some(self.evaluate(y))
+    }
+
     /// Computes full evaluation tables `(eq_evals, eq_plus_one_evals)` over the
     /// Boolean hypercube, where:
     ///
@@ -217,6 +227,17 @@ mod tests {
         assert!(eq_plus_one.evaluate(&y).is_zero());
     }
 
+    #[test]
+    fn try_evaluate_rejects_dimension_mismatch() {
+        let eq_plus_one = EqPlusOnePolynomial::new(vec![Fr::zero(), Fr::one()]);
+
+        assert_eq!(eq_plus_one.try_evaluate(&[Fr::one()]), None);
+        assert_eq!(
+            eq_plus_one.try_evaluate(&[Fr::one(), Fr::zero()]),
+            Some(eq_plus_one.evaluate(&[Fr::one(), Fr::zero()]))
+        );
+    }
+
     #[test]
     fn evals_table_matches_pointwise() {
         let mut rng = ChaCha20Rng::seed_from_u64(42);
diff --git a/crates/jolt-poly/src/identity.rs b/crates/jolt-poly/src/identity.rs
index e2df04a5a1..8f0538de1d 100644
--- a/crates/jolt-poly/src/identity.rs
+++ b/crates/jolt-poly/src/identity.rs
@@ -24,6 +24,37 @@ impl IdentityPolynomial {
         self.num_vars
     }
 
+    pub fn try_evaluate<F: Field>(&self, point: &[F]) -> Option<F> {
+        if point.len() != self.num_vars {
+            return None;
+        }
+        Some(evaluate_identity(point.iter().copied(), self.num_vars))
+    }
+
+    pub fn try_evaluate_projected<F: Field>(
+        &self,
+        point: &[F],
+        offset: usize,
+        stride: usize,
+    ) -> Option<F> {
+        if self.num_vars == 0 {
+            return Some(F::zero());
+        }
+        if stride == 0 {
+            return None;
+        }
+        let last_index = stride
+            .checked_mul(self.num_vars - 1)
+            .and_then(|last_offset| offset.checked_add(last_offset))?;
+        if last_index >= point.len() {
+            return None;
+        }
+        Some(evaluate_identity(
+            (0..self.num_vars).map(|index| point[offset + stride * index]),
+            self.num_vars,
+        ))
+    }
+
     /// Evaluates $\widetilde{I}(r) = \sum_{i=1}^{n} r_i \cdot 2^{n-i}$.
     ///
     /// Time: $O(n)$. No heap allocation.
@@ -34,14 +65,16 @@ impl IdentityPolynomial {
             self.num_vars,
             "point dimension must match num_vars"
         );
-        let n = self.num_vars;
-        point
-            .iter()
-            .enumerate()
-            .fold(F::zero(), |acc, (i, &r_i)| acc + r_i.mul_pow_2(n - 1 - i))
+        evaluate_identity(point.iter().copied(), self.num_vars)
     }
 }
 
+fn evaluate_identity<F: Field>(values: impl Iterator<Item = F>, num_vars: usize) -> F {
+    values.enumerate().fold(F::zero(), |acc, (index, value)| {
+        acc + value.mul_pow_2(num_vars - 1 - index)
+    })
+}
+
 impl<F: Field> crate::MultilinearEvaluation<F> for IdentityPolynomial {
     fn num_vars(&self) -> usize {
         self.num_vars
@@ -97,4 +130,37 @@ mod tests {
         assert!(id.evaluate(&[Fr::zero()]).is_zero());
         assert_eq!(id.evaluate(&[Fr::one()]), Fr::one());
     }
+
+    #[test]
+    fn try_evaluate_rejects_dimension_mismatch() {
+        let id = IdentityPolynomial::new(2);
+        assert_eq!(id.try_evaluate::<Fr>(&[Fr::one()]), None);
+    }
+
+    #[test]
+    fn projected_identity_uses_offset_and_stride() {
+        let id = IdentityPolynomial::new(3);
+        let point = [
+            Fr::from_u64(1),
+            Fr::from_u64(9),
+            Fr::from_u64(0),
+            Fr::from_u64(8),
+            Fr::from_u64(1),
+        ];
+
+        assert_eq!(
+            id.try_evaluate_projected(&point, 0, 2),
+            Some(Fr::from_u64(5))
+        );
+    }
+
+    #[test]
+    fn projected_identity_rejects_out_of_range_projection() {
+        let id = IdentityPolynomial::new(3);
+        assert_eq!(id.try_evaluate_projected::<Fr>(&[Fr::one()], 0, 2), None);
+        assert_eq!(
+            id.try_evaluate_projected::<Fr>(&[Fr::one(), Fr::one()], 0, 0),
+            None
+        );
+    }
 }
diff --git a/crates/jolt-poly/src/lt.rs b/crates/jolt-poly/src/lt.rs
index c220ff6a6d..9dee26837b 100644
--- a/crates/jolt-poly/src/lt.rs
+++ b/crates/jolt-poly/src/lt.rs
@@ -124,6 +124,20 @@ impl<F: Field> LtPolynomial<F> {
     /// Both `x` and `r` are big-endian. Time: O(n). Space: O(1).
     pub fn evaluate(x: &[F], r: &[F]) -> F {
         assert_eq!(x.len(), r.len(), "LT point dimension mismatch");
+        Self::evaluate_equal_length(x, r)
+    }
+
+    /// Fallible version of [`evaluate`](Self::evaluate) for verifier-side callers.
+    ///
+    /// Returns `None` when the two points have different dimensions.
+    pub fn try_evaluate(x: &[F], r: &[F]) -> Option<F> {
+        if x.len() != r.len() {
+            return None;
+        }
+        Some(Self::evaluate_equal_length(x, r))
+    }
+
+    fn evaluate_equal_length(x: &[F], r: &[F]) -> F {
         let mut lt = F::zero();
         let mut eq_prefix = F::one();
         for (&xi, &ri) in x.iter().zip(r.iter()) {
@@ -220,6 +234,18 @@ mod tests {
         }
     }
 
+    #[test]
+    fn try_evaluate_checks_dimension() {
+        let x = vec![Fr::zero(), Fr::one()];
+        let r = vec![Fr::one(), Fr::zero()];
+
+        assert_eq!(
+            LtPolynomial::try_evaluate(&x, &r),
+            Some(LtPolynomial::evaluate(&x, &r))
+        );
+        assert_eq!(LtPolynomial::try_evaluate(&x, &r[..1]), None);
+    }
+
     #[test]
     fn split_matches_full_table() {
         let mut rng = ChaCha20Rng::seed_from_u64(99);
diff --git a/crates/jolt-prover/src/prover.rs b/crates/jolt-prover/src/prover.rs
index 1907d74906..b0e33595f4 100644
--- a/crates/jolt-prover/src/prover.rs
+++ b/crates/jolt-prover/src/prover.rs
@@ -8,7 +8,7 @@ use jolt_field::Fr;
 use jolt_kernels::{stage1, stage2, stage3, stage4, stage5, stage6, stage7};
 use jolt_openings::CommitmentScheme;
 use jolt_poly::{EqPolynomial, Polynomial};
-use jolt_transcript::{AppendToTranscript, Blake2bTranscript, LabelWithCount, Transcript};
+use jolt_transcript::{Blake2bTranscript, Transcript};
 use jolt_verifier::{JoltEvaluationProof, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput};
 use jolt_witness::{stage4_ram_val_init_opening, CycleInput, Stage45SparseTraceWitness, Stage6BytecodeEntry as WitnessStage6BytecodeEntry, Stage6WitnessParams, Stage6WitnessPolynomials, Stage6WitnessSlices};
 use rayon::prelude::*;
@@ -268,6 +268,61 @@ where
     Ok((proof, artifacts))
 }
 
+impl stage8_stage::Stage8NamedEvalView<Fr> for stage7::Stage7NamedEval<Fr> {
+    fn name(&self) -> &'static str {
+        self.name
+    }
+
+    fn value(&self) -> Fr {
+        self.value
+    }
+}
+
+impl stage8_stage::Stage8SumcheckOutputView<Fr>
+    for stage7::Stage7SumcheckOutput<Fr>
+{
+    type Eval = stage7::Stage7NamedEval<Fr>;
+
+    fn point(&self) -> &[Fr] {
+        &self.point
+    }
+
+    fn evals(&self) -> &[Self::Eval] {
+        &self.evals
+    }
+}
+
+impl stage8_stage::Stage8OpeningInputView<Fr>
+    for stage7::Stage7OpeningInputValue<Fr>
+{
+    fn symbol(&self) -> &'static str {
+        self.symbol
+    }
+
+    fn point(&self) -> &[Fr] {
+        &self.point
+    }
+}
+
+impl From<stage8_stage::Stage8EvaluationOpeningPointError> for JoltEvaluationProveError {
+    fn from(error: stage8_stage::Stage8EvaluationOpeningPointError) -> Self {
+        match error {
+            stage8_stage::Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint => {
+                Self::MissingStage7EvaluationPoint
+            }
+            stage8_stage::Stage8EvaluationOpeningPointError::InvalidPointLength {
+                artifact,
+                expected,
+                actual,
+            } => Self::InvalidPointLength {
+                artifact,
+                expected,
+                actual,
+            },
+        }
+    }
+}
+
 pub fn prove_jolt_evaluation_proof<I, T>(
     program: &'static stage8_stage::Stage8EvaluationProgramPlan,
     commitment_inputs: &mut I,
@@ -283,17 +338,24 @@ where
     T: Transcript<Challenge = Fr>,
 {
     let _claims_span = tracing::info_span!("bolt.evaluate.claims").entered();
-    let (sumcheck_address_point, stage7_values) = stage7_claim_values(program, stage7)?;
-    let address_point = reverse_point(&sumcheck_address_point);
+    let (sumcheck_address_point, stage7_values) =
+        stage8_stage::stage7_claim_values(program, &stage7.sumchecks)
+            .ok_or(JoltEvaluationProveError::MissingStage7RaEval)?;
+    let address_point = stage8_stage::reverse_point(&sumcheck_address_point);
     let (opening_point, log_t) =
-        stage7_evaluation_opening_point(program, &address_point, stage7_openings)?;
+        stage8_stage::stage7_evaluation_opening_point(program, &address_point, stage7_openings)?;
     let lagrange_factor = EqPolynomial::<Fr>::zero_selector(&address_point);
-    let claims = evaluation_claims(program, stage6, &stage7_values, lagrange_factor)?;
+    let claims =
+        stage8_stage::evaluation_claims(program, &stage6.sumchecks, &stage7_values, lagrange_factor)
+            .map_err(|error| JoltEvaluationProveError::MissingStageEval {
+                stage: error.stage,
+                eval: error.eval,
+            })?;
     drop(_claims_span);
 
     let _rlc_span = tracing::info_span!("bolt.evaluate.rlc_claims").entered();
-    append_rlc_claims(transcript, &claims);
-    let gamma_powers = gamma_powers(transcript, claims.len());
+    stage8_stage::append_rlc_claims(transcript, &claims);
+    let gamma_powers = stage8_stage::gamma_powers(transcript, claims.len());
     let joint_claim = claims
         .iter()
         .zip(&gamma_powers)
@@ -334,137 +396,9 @@ where
     Ok(JoltEvaluationProof { joint_opening_proof })
 }
 
-struct EvaluationClaim {
-    oracle: &'static str,
-    source_stage: &'static str,
-    value: Fr,
-}
-
-fn stage6_eval_claim(
-    artifacts: &stage6::Stage6ExecutionArtifacts<Fr>,
-    eval_name: &'static str,
-) -> Result<Fr, JoltEvaluationProveError> {
-    for output in &artifacts.sumchecks {
-        if let Some(eval) = output.evals.iter().find(|eval| eval.name == eval_name) {
-            return Ok(eval.value);
-        }
-    }
-    Err(JoltEvaluationProveError::MissingStageEval {
-        stage: "stage6",
-        eval: eval_name,
-    })
-}
-
-fn evaluation_claims(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    stage6: &stage6::Stage6ExecutionArtifacts<Fr>,
-    stage7_values: &std::collections::BTreeMap<&'static str, Fr>,
-    lagrange_factor: Fr,
-) -> Result<Vec<EvaluationClaim>, JoltEvaluationProveError> {
-    let mut claims = Vec::with_capacity(program.opening_claims.len());
-    for plan in program.opening_claims {
-        let value = match plan.source_stage {
-            "stage6" => stage6_eval_claim(stage6, plan.source_claim)? * lagrange_factor,
-            "stage7" => *stage7_values.get(plan.source_claim).ok_or(
-                JoltEvaluationProveError::MissingStageEval {
-                    stage: plan.source_stage,
-                    eval: plan.source_claim,
-                },
-            )?,
-            _ => {
-                return Err(JoltEvaluationProveError::MissingStageEval {
-                    stage: plan.source_stage,
-                    eval: plan.source_claim,
-                });
-            }
-        };
-        claims.push(EvaluationClaim {
-            oracle: plan.oracle,
-            source_stage: plan.source_stage,
-            value,
-        });
-    }
-    Ok(claims)
-}
-
-fn stage7_claim_values(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    artifacts: &stage7::Stage7ExecutionArtifacts<Fr>,
-) -> Result<(Vec<Fr>, std::collections::BTreeMap<&'static str, Fr>), JoltEvaluationProveError> {
-    let stage7_plans = program
-        .opening_claims
-        .iter()
-        .filter(|plan| plan.source_stage == "stage7")
-        .collect::<Vec<_>>();
-    for output in &artifacts.sumchecks {
-        let mut values = std::collections::BTreeMap::new();
-        for plan in &stage7_plans {
-            if let Some(eval) = output.evals.iter().find(|eval| eval.name == plan.source_claim) {
-                let _ = values.insert(plan.source_claim, eval.value);
-            }
-        }
-        if values.len() == stage7_plans.len() {
-            return Ok((output.point.clone(), values));
-        }
-    }
-    Err(JoltEvaluationProveError::MissingStage7RaEval)
-}
-
-fn reverse_point(point: &[Fr]) -> Vec<Fr> {
-    point.iter().rev().copied().collect()
-}
-
-fn stage7_evaluation_opening_point(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    address_point: &[Fr],
-    stage7_openings: &[stage7::Stage7OpeningInputValue<Fr>],
-) -> Result<(Vec<Fr>, usize), JoltEvaluationProveError> {
-    let cycle_source_symbol = program.evaluation_point_source.source_claim;
-    let cycle_source = stage7_openings
-        .iter()
-        .find(|input| input.symbol == cycle_source_symbol)
-        .ok_or(JoltEvaluationProveError::MissingStage7EvaluationPoint)?;
-    if cycle_source.point.len() < address_point.len() {
-        return Err(JoltEvaluationProveError::InvalidPointLength {
-            artifact: cycle_source_symbol,
-            expected: address_point.len(),
-            actual: cycle_source.point.len(),
-        });
-    }
-    let cycle_len = cycle_source.point.len() - address_point.len();
-    let mut point = Vec::with_capacity(cycle_source.point.len());
-    point.extend_from_slice(address_point);
-    point.extend_from_slice(&cycle_source.point[address_point.len()..]);
-    Ok((point, cycle_len))
-}
-
-fn append_rlc_claims<T>(transcript: &mut T, claims: &[EvaluationClaim])
-where
-    T: Transcript<Challenge = Fr>,
-{
-    transcript.append(&LabelWithCount(b"rlc_claims", claims.len() as u64));
-    for claim in claims {
-        claim.value.append_to_transcript(transcript);
-    }
-}
-
-fn gamma_powers<T>(transcript: &mut T, count: usize) -> Vec<Fr>
-where
-    T: Transcript<Challenge = Fr>,
-{
-    let gamma = transcript.challenge();
-    let mut powers = Vec::with_capacity(count);
-    let mut power = Fr::from_u64(1);
-    for _ in 0..count {
-        powers.push(power);
-        power *= gamma;
-    }
-    powers
-}
-
 fn materialize_joint_polynomial<I>(
     commitment_inputs: &mut I,
-    claims: &[EvaluationClaim],
+    claims: &[stage8_stage::Stage8EvaluationClaim<Fr>],
     gamma_powers: &[Fr],
     log_t: usize,
     main_num_vars: usize,
@@ -476,7 +410,7 @@ where
     let main_len = target_len(main_num_vars)?;
     let mut joint = vec![Fr::from_u64(0); main_len];
     for (claim, gamma) in claims.iter().zip(gamma_powers) {
-        if claim.source_stage == "stage6" {
+        if claim.source_stage == stage8_stage::Stage8SourceStage::Stage6 {
             add_oracle_scaled(commitment_inputs, &mut joint, claim.oracle, log_t, trace_len, *gamma)?;
         } else {
             add_oracle_scaled(
@@ -551,7 +485,7 @@ where
 
 fn joint_opening_hint(
     commitments: &commitment_stage::CommitmentArtifacts,
-    claims: &[EvaluationClaim],
+    claims: &[stage8_stage::Stage8EvaluationClaim<Fr>],
     gamma_powers: &[Fr],
 ) -> Result<DoryHint, JoltEvaluationProveError> {
     let mut coefficients = std::collections::BTreeMap::<&'static str, Fr>::new();
diff --git a/crates/jolt-prover/src/stages/commitment.rs b/crates/jolt-prover/src/stages/commitment.rs
index eb744d8c88..50027da647 100644
--- a/crates/jolt-prover/src/stages/commitment.rs
+++ b/crates/jolt-prover/src/stages/commitment.rs
@@ -798,46 +798,11 @@ pub const ORACLE_PLANS: &[OraclePlan] = &[
     OraclePlan { oracle: "TrustedAdvice", domain: "jolt.trace_domain", num_vars: 16 },
 ];
 pub const COMMITMENT_BATCH_0_ORACLES: &[&str] = &[
-    "RdInc",
-    "RamInc",
-    "InstructionRa_0",
-    "InstructionRa_1",
-    "InstructionRa_2",
-    "InstructionRa_3",
-    "InstructionRa_4",
-    "InstructionRa_5",
-    "InstructionRa_6",
-    "InstructionRa_7",
-    "InstructionRa_8",
-    "InstructionRa_9",
-    "InstructionRa_10",
-    "InstructionRa_11",
-    "InstructionRa_12",
-    "InstructionRa_13",
-    "InstructionRa_14",
-    "InstructionRa_15",
-    "InstructionRa_16",
-    "InstructionRa_17",
-    "InstructionRa_18",
-    "InstructionRa_19",
-    "InstructionRa_20",
-    "InstructionRa_21",
-    "InstructionRa_22",
-    "InstructionRa_23",
-    "InstructionRa_24",
-    "InstructionRa_25",
-    "InstructionRa_26",
-    "InstructionRa_27",
-    "InstructionRa_28",
-    "InstructionRa_29",
-    "InstructionRa_30",
-    "InstructionRa_31",
-    "RamRa_0",
-    "RamRa_1",
-    "RamRa_2",
-    "RamRa_3",
-    "BytecodeRa_0",
-    "BytecodeRa_1",
+    "RdInc", "RamInc", "InstructionRa_0", "InstructionRa_1", "InstructionRa_2", "InstructionRa_3", "InstructionRa_4", "InstructionRa_5",
+    "InstructionRa_6", "InstructionRa_7", "InstructionRa_8", "InstructionRa_9", "InstructionRa_10", "InstructionRa_11", "InstructionRa_12", "InstructionRa_13",
+    "InstructionRa_14", "InstructionRa_15", "InstructionRa_16", "InstructionRa_17", "InstructionRa_18", "InstructionRa_19", "InstructionRa_20", "InstructionRa_21",
+    "InstructionRa_22", "InstructionRa_23", "InstructionRa_24", "InstructionRa_25", "InstructionRa_26", "InstructionRa_27", "InstructionRa_28", "InstructionRa_29",
+    "InstructionRa_30", "InstructionRa_31", "RamRa_0", "RamRa_1", "RamRa_2", "RamRa_3", "BytecodeRa_0", "BytecodeRa_1",
     "BytecodeRa_2",
 ];
 pub const COMMITMENT_BATCH_PLANS: &[CommitmentBatchPlan] = &[
diff --git a/crates/jolt-prover/src/stages/stage1_outer.rs b/crates/jolt-prover/src/stages/stage1_outer.rs
index e31d49a81e..a5f2b9ea7e 100644
--- a/crates/jolt-prover/src/stages/stage1_outer.rs
+++ b/crates/jolt-prover/src/stages/stage1_outer.rs
@@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript};
 
 pub type DefaultStage1Transcript = Blake2bTranscript<Fr>;
 
-pub const STAGE1_PARAMS: Stage1Params = Stage1Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE1_PARAMS: Stage1Params = Stage1Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE1_TRANSCRIPT_SQUEEZES: &[Stage1TranscriptSqueezePlan] = &[
     Stage1TranscriptSqueezePlan { symbol: "stage1.tau", label: "outer_tau", kind: "challenge_vector", count: 18 },
 ];
@@ -32,29 +28,21 @@ pub const STAGE1_SUMCHECK_BATCH_0_ORDERED_CLAIMS: &[&str] = &["stage1.uniskip.in
 
 pub const STAGE1_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &["stage1.uniskip.input"];
 
-pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    1,
-];
+pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1];
 
 pub const STAGE1_SUMCHECK_BATCH_1_ORDERED_CLAIMS: &[&str] = &["stage1.outer_remaining.input"];
 
 pub const STAGE1_SUMCHECK_BATCH_1_CLAIM_OPERANDS: &[&str] = &["stage1.outer_remaining.input"];
 
-pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[
-    17,
-];
+pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[17];
 
 pub const STAGE1_SUMCHECK_BATCHES: &[Stage1SumcheckBatchPlan] = &[
     Stage1SumcheckBatchPlan { symbol: "stage1.uniskip.batch", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: STAGE1_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE1_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
     Stage1SumcheckBatchPlan { symbol: "stage1.outer_remaining.batch", stage: "stage1", proof_slot: "stage1.sumcheck", policy: "jolt_core_front_loaded", count: 1, ordered_claims: STAGE1_SUMCHECK_BATCH_1_ORDERED_CLAIMS, claim_operands: STAGE1_SUMCHECK_BATCH_1_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE },
 ];
-pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    1,
-];
+pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1];
 
-pub const STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[
-    17,
-];
+pub const STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[17];
 
 pub const STAGE1_SUMCHECK_DRIVERS: &[Stage1SumcheckDriverPlan] = &[
     Stage1SumcheckDriverPlan { symbol: "stage1.uniskip.sumcheck", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", kernel: Some("jolt.cpu.stage1.outer.uniskip"), relation: None, batch: "stage1.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 27 },
diff --git a/crates/jolt-prover/src/stages/stage2.rs b/crates/jolt-prover/src/stages/stage2.rs
index ece68d1c0b..a5a5deed8d 100644
--- a/crates/jolt-prover/src/stages/stage2.rs
+++ b/crates/jolt-prover/src/stages/stage2.rs
@@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript};
 
 pub type DefaultStage2Transcript = Blake2bTranscript<Fr>;
 
-pub const STAGE2_PARAMS: Stage2Params = Stage2Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE2_PARAMS: Stage2Params = Stage2Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE2_PROGRAM_STEPS: &[Stage2ProgramStepPlan] = &[
     Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.product_virtual.tau_high" },
     Stage2ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage2.product_virtual.uniskip.sumcheck" },
@@ -207,9 +203,7 @@ pub const STAGE2_SUMCHECK_BATCH_0_ORDERED_CLAIMS: &[&str] = &["stage2.product_vi
 
 pub const STAGE2_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &["stage2.product_virtual.uniskip.input"];
 
-pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    1,
-];
+pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1];
 
 pub const STAGE2_SUMCHECK_BATCH_1_ORDERED_CLAIMS: &[&str] = &[
     "stage2.ram_read_write.input",
@@ -227,23 +221,15 @@ pub const STAGE2_SUMCHECK_BATCH_1_CLAIM_OPERANDS: &[&str] = &[
     "stage2.ram_output.input",
 ];
 
-pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[
-    16,
-    16,
-];
+pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[16, 16];
 
 pub const STAGE2_SUMCHECK_BATCHES: &[Stage2SumcheckBatchPlan] = &[
     Stage2SumcheckBatchPlan { symbol: "stage2.product_virtual.uniskip.batch", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: STAGE2_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE2_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
     Stage2SumcheckBatchPlan { symbol: "stage2.batch", stage: "stage2", proof_slot: "stage2.sumcheck", policy: "jolt_core_stage2_aligned", count: 5, ordered_claims: STAGE2_SUMCHECK_BATCH_1_ORDERED_CLAIMS, claim_operands: STAGE2_SUMCHECK_BATCH_1_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE },
 ];
-pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    1,
-];
+pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1];
 
-pub const STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[
-    16,
-    16,
-];
+pub const STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[16, 16];
 
 pub const STAGE2_SUMCHECK_DRIVERS: &[Stage2SumcheckDriverPlan] = &[
     Stage2SumcheckDriverPlan { symbol: "stage2.product_virtual.uniskip.sumcheck", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", kernel: Some("jolt.cpu.stage2.product_virtual.uniskip"), relation: None, batch: "stage2.product_virtual.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 6 },
diff --git a/crates/jolt-prover/src/stages/stage3.rs b/crates/jolt-prover/src/stages/stage3.rs
index f1ca47494b..6a4dab2e86 100644
--- a/crates/jolt-prover/src/stages/stage3.rs
+++ b/crates/jolt-prover/src/stages/stage3.rs
@@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript};
 
 pub type DefaultStage3Transcript = Blake2bTranscript<Fr>;
 
-pub const STAGE3_PARAMS: Stage3Params = Stage3Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE3_PARAMS: Stage3Params = Stage3Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[
     Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.spartan_shift.gamma" },
     Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.instruction_input.gamma" },
@@ -196,16 +192,12 @@ pub const STAGE3_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[
     "stage3.registers_claim_reduction.input",
 ];
 
-pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    16,
-];
+pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16];
 
 pub const STAGE3_SUMCHECK_BATCHES: &[Stage3SumcheckBatchPlan] = &[
     Stage3SumcheckBatchPlan { symbol: "stage3.batch", stage: "stage3", proof_slot: "stage3.sumcheck", policy: "jolt_core_stage3_aligned", count: 3, ordered_claims: STAGE3_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE3_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
-pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    16,
-];
+pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16];
 
 pub const STAGE3_SUMCHECK_DRIVERS: &[Stage3SumcheckDriverPlan] = &[
     Stage3SumcheckDriverPlan { symbol: "stage3.sumcheck", stage: "stage3", proof_slot: "stage3.sumcheck", kernel: Some("jolt.cpu.stage3.batched"), relation: None, batch: "stage3.batch", policy: "jolt_core_stage3_aligned", round_schedule: STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 16, degree: 3 },
diff --git a/crates/jolt-prover/src/stages/stage4.rs b/crates/jolt-prover/src/stages/stage4.rs
index 03a8258a94..db47762400 100644
--- a/crates/jolt-prover/src/stages/stage4.rs
+++ b/crates/jolt-prover/src/stages/stage4.rs
@@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript};
 
 pub type DefaultStage4Transcript = Blake2bTranscript<Fr>;
 
-pub const STAGE4_PARAMS: Stage4Params = Stage4Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE4_PARAMS: Stage4Params = Stage4Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE4_PROGRAM_STEPS: &[Stage4ProgramStepPlan] = &[
     Stage4ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage4.registers_read_write.gamma" },
     Stage4ProgramStepPlan { kind: "transcript_absorb_bytes", symbol: "stage4.ram_val_check.domain_separator" },
@@ -127,18 +123,12 @@ pub const STAGE4_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[
     "stage4.ram_val_check.input",
 ];
 
-pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    16,
-    7,
-];
+pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16, 7];
 
 pub const STAGE4_SUMCHECK_BATCHES: &[Stage4SumcheckBatchPlan] = &[
     Stage4SumcheckBatchPlan { symbol: "stage4.batch", stage: "stage4", proof_slot: "stage4.sumcheck", policy: "jolt_core_stage4_aligned", count: 2, ordered_claims: STAGE4_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE4_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
-pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    16,
-    7,
-];
+pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16, 7];
 
 pub const STAGE4_SUMCHECK_DRIVERS: &[Stage4SumcheckDriverPlan] = &[
     Stage4SumcheckDriverPlan { symbol: "stage4.sumcheck", stage: "stage4", proof_slot: "stage4.sumcheck", kernel: Some("jolt.cpu.stage4.batched"), relation: None, batch: "stage4.batch", policy: "jolt_core_stage4_aligned", round_schedule: STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 23, degree: 3 },
diff --git a/crates/jolt-prover/src/stages/stage5.rs b/crates/jolt-prover/src/stages/stage5.rs
index 22604c721f..f1ccc4a3f1 100644
--- a/crates/jolt-prover/src/stages/stage5.rs
+++ b/crates/jolt-prover/src/stages/stage5.rs
@@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript};
 
 pub type DefaultStage5Transcript = Blake2bTranscript<Fr>;
 
-pub const STAGE5_PARAMS: Stage5Params = Stage5Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE5_PARAMS: Stage5Params = Stage5Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE5_PROGRAM_STEPS: &[Stage5ProgramStepPlan] = &[
     Stage5ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage5.instruction_read_raf.gamma" },
     Stage5ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage5.ram_ra_claim_reduction.gamma" },
@@ -135,18 +131,12 @@ pub const STAGE5_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[
     "stage5.registers_val_evaluation.input",
 ];
 
-pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    128,
-    16,
-];
+pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[128, 16];
 
 pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[
     Stage5SumcheckBatchPlan { symbol: "stage5.batch", stage: "stage5", proof_slot: "stage5.sumcheck", policy: "jolt_core_stage5_aligned", count: 3, ordered_claims: STAGE5_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE5_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
-pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    128,
-    16,
-];
+pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[128, 16];
 
 pub const STAGE5_SUMCHECK_DRIVERS: &[Stage5SumcheckDriverPlan] = &[
     Stage5SumcheckDriverPlan { symbol: "stage5.sumcheck", stage: "stage5", proof_slot: "stage5.sumcheck", kernel: Some("jolt.cpu.stage5.batched"), relation: None, batch: "stage5.batch", policy: "jolt_core_stage5_aligned", round_schedule: STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 144, degree: 10 },
diff --git a/crates/jolt-prover/src/stages/stage6.rs b/crates/jolt-prover/src/stages/stage6.rs
index ad59b1a999..3165c447dc 100644
--- a/crates/jolt-prover/src/stages/stage6.rs
+++ b/crates/jolt-prover/src/stages/stage6.rs
@@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript};
 
 pub type DefaultStage6Transcript = Blake2bTranscript<Fr>;
 
-pub const STAGE6_PARAMS: Stage6Params = Stage6Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE6_PARAMS: Stage6Params = Stage6Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE6_PROGRAM_STEPS: &[Stage6ProgramStepPlan] = &[
     Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.gamma" },
     Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage1_gamma" },
@@ -138,1613 +134,1533 @@ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[
     Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 },
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_0: &[&str] = &["stage6.booleanity.gamma"];
-
-pub const STAGE6_FIELD_EXPR_OPERANDS_1: &[&str] = &["stage6.bytecode_read_raf.stage1_gamma"];
+pub const STAGE6_FIELD_EXPR_OPERANDS_0: &[&str] = &["stage6.bytecode_read_raf.stage1_gamma"];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_2: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_1: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow",
     "stage6.input.stage1.Imm",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_3: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_2: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow",
     "stage6.input.stage1.OpFlagAddOperands",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_4: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_3: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow",
     "stage6.input.stage1.OpFlagSubtractOperands",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_5: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_4: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow",
     "stage6.input.stage1.OpFlagMultiplyOperands",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_6: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_5: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow",
     "stage6.input.stage1.OpFlagLoad",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_7: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_6: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow",
     "stage6.input.stage1.OpFlagStore",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_8: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_7: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow",
     "stage6.input.stage1.OpFlagJump",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_9: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_8: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow",
     "stage6.input.stage1.OpFlagWriteLookupOutputToRD",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_10: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_9: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow",
     "stage6.input.stage1.OpFlagVirtualInstruction",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_11: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_10: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow",
     "stage6.input.stage1.OpFlagAssert",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_12: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_11: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow",
     "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_13: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_12: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow",
     "stage6.input.stage1.OpFlagAdvice",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_14: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_13: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow",
     "stage6.input.stage1.OpFlagIsCompressed",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_15: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_14: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow",
     "stage6.input.stage1.OpFlagIsFirstInSequence",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_16: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_15: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow",
     "stage6.input.stage1.OpFlagIsLastInSequence",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_17: &[&str] = &["stage6.bytecode_read_raf.gamma"];
+pub const STAGE6_FIELD_EXPR_OPERANDS_16: &[&str] = &["stage6.bytecode_read_raf.gamma"];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_18: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_17: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term16.gamma_pow",
     "stage6.input.stage2.OpFlagJump",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_19: &[&str] = &["stage6.bytecode_read_raf.stage2_gamma"];
+pub const STAGE6_FIELD_EXPR_OPERANDS_18: &[&str] = &["stage6.bytecode_read_raf.stage2_gamma"];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_20: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_19: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow",
     "stage6.input.stage2.InstructionFlagBranch",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_21: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_20: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term17.gamma_pow",
     "stage6.bytecode_read_raf.claim.term17.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_22: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_21: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow",
     "stage6.input.stage2.OpFlagWriteLookupOutputToRD",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_23: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_22: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term18.gamma_pow",
     "stage6.bytecode_read_raf.claim.term18.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_24: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_23: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow",
     "stage6.input.stage2.OpFlagVirtualInstruction",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_25: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_24: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term19.gamma_pow",
     "stage6.bytecode_read_raf.claim.term19.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_26: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_25: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term20.gamma_pow",
     "stage6.input.stage3.instruction_input.Imm",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_27: &[&str] = &["stage6.bytecode_read_raf.stage3_gamma"];
+pub const STAGE6_FIELD_EXPR_OPERANDS_26: &[&str] = &["stage6.bytecode_read_raf.stage3_gamma"];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_28: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_27: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow",
     "stage6.input.stage3.spartan_shift.UnexpandedPC",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_29: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_28: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term21.gamma_pow",
     "stage6.bytecode_read_raf.claim.term21.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_30: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_29: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow",
     "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_31: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_30: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term22.gamma_pow",
     "stage6.bytecode_read_raf.claim.term22.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_32: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_31: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow",
     "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_33: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_32: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term23.gamma_pow",
     "stage6.bytecode_read_raf.claim.term23.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_34: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_33: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow",
     "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_35: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_34: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term24.gamma_pow",
     "stage6.bytecode_read_raf.claim.term24.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_36: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_35: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow",
     "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_37: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_36: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term25.gamma_pow",
     "stage6.bytecode_read_raf.claim.term25.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_38: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_37: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow",
     "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_39: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_38: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term26.gamma_pow",
     "stage6.bytecode_read_raf.claim.term26.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_40: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_39: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow",
     "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_41: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_40: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term27.gamma_pow",
     "stage6.bytecode_read_raf.claim.term27.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_42: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_41: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow",
     "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_43: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_42: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term28.gamma_pow",
     "stage6.bytecode_read_raf.claim.term28.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_44: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_43: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term29.gamma_pow",
     "stage6.input.stage4.RdWa",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_45: &[&str] = &["stage6.bytecode_read_raf.stage4_gamma"];
+pub const STAGE6_FIELD_EXPR_OPERANDS_44: &[&str] = &["stage6.bytecode_read_raf.stage4_gamma"];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_46: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_45: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow",
     "stage6.input.stage4.Rs1Ra",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_47: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_46: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term30.gamma_pow",
     "stage6.bytecode_read_raf.claim.term30.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_48: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_47: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow",
     "stage6.input.stage4.Rs2Ra",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_49: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_48: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term31.gamma_pow",
     "stage6.bytecode_read_raf.claim.term31.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_50: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_49: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term32.gamma_pow",
     "stage6.input.stage5.registers_val_evaluation.RdWa",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_51: &[&str] = &["stage6.bytecode_read_raf.stage5_gamma"];
+pub const STAGE6_FIELD_EXPR_OPERANDS_50: &[&str] = &["stage6.bytecode_read_raf.stage5_gamma"];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_52: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_51: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow",
     "stage6.input.stage5.InstructionRafFlag",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_53: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_52: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term33.gamma_pow",
     "stage6.bytecode_read_raf.claim.term33.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_54: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_53: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_0",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_55: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_54: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term34.gamma_pow",
     "stage6.bytecode_read_raf.claim.term34.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_56: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_55: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_1",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_57: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_56: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term35.gamma_pow",
     "stage6.bytecode_read_raf.claim.term35.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_58: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_57: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_2",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_59: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_58: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term36.gamma_pow",
     "stage6.bytecode_read_raf.claim.term36.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_60: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_59: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_3",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_61: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_60: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term37.gamma_pow",
     "stage6.bytecode_read_raf.claim.term37.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_62: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_61: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_4",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_63: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_62: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term38.gamma_pow",
     "stage6.bytecode_read_raf.claim.term38.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_64: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_63: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_5",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_65: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_64: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term39.gamma_pow",
     "stage6.bytecode_read_raf.claim.term39.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_66: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_65: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_6",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_67: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_66: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term40.gamma_pow",
     "stage6.bytecode_read_raf.claim.term40.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_68: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_67: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_7",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_69: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_68: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term41.gamma_pow",
     "stage6.bytecode_read_raf.claim.term41.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_70: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_69: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_8",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_71: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_70: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term42.gamma_pow",
     "stage6.bytecode_read_raf.claim.term42.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_72: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_71: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_9",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_73: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_72: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term43.gamma_pow",
     "stage6.bytecode_read_raf.claim.term43.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_74: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_73: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_10",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_75: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_74: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term44.gamma_pow",
     "stage6.bytecode_read_raf.claim.term44.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_76: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_75: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_11",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_77: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_76: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term45.gamma_pow",
     "stage6.bytecode_read_raf.claim.term45.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_78: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_77: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_12",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_79: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_78: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term46.gamma_pow",
     "stage6.bytecode_read_raf.claim.term46.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_80: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_79: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_13",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_81: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_80: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term47.gamma_pow",
     "stage6.bytecode_read_raf.claim.term47.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_82: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_81: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_14",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_83: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_82: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term48.gamma_pow",
     "stage6.bytecode_read_raf.claim.term48.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_84: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_83: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_15",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_85: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_84: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term49.gamma_pow",
     "stage6.bytecode_read_raf.claim.term49.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_86: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_85: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_16",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_87: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_86: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term50.gamma_pow",
     "stage6.bytecode_read_raf.claim.term50.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_88: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_87: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_17",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_89: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_88: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term51.gamma_pow",
     "stage6.bytecode_read_raf.claim.term51.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_90: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_89: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_18",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_91: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_90: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term52.gamma_pow",
     "stage6.bytecode_read_raf.claim.term52.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_92: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_91: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_19",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_93: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_92: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term53.gamma_pow",
     "stage6.bytecode_read_raf.claim.term53.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_94: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_93: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_20",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_95: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_94: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term54.gamma_pow",
     "stage6.bytecode_read_raf.claim.term54.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_96: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_95: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_21",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_97: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_96: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term55.gamma_pow",
     "stage6.bytecode_read_raf.claim.term55.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_98: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_97: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_22",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_99: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_98: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term56.gamma_pow",
     "stage6.bytecode_read_raf.claim.term56.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_100: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_99: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_23",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_101: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_100: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term57.gamma_pow",
     "stage6.bytecode_read_raf.claim.term57.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_102: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_101: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_24",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_103: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_102: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term58.gamma_pow",
     "stage6.bytecode_read_raf.claim.term58.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_104: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_103: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_25",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_105: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_104: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term59.gamma_pow",
     "stage6.bytecode_read_raf.claim.term59.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_106: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_105: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_26",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_107: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_106: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term60.gamma_pow",
     "stage6.bytecode_read_raf.claim.term60.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_108: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_107: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_27",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_109: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_108: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term61.gamma_pow",
     "stage6.bytecode_read_raf.claim.term61.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_110: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_109: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_28",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_111: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_110: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term62.gamma_pow",
     "stage6.bytecode_read_raf.claim.term62.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_112: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_111: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_29",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_113: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_112: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term63.gamma_pow",
     "stage6.bytecode_read_raf.claim.term63.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_114: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_113: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_30",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_115: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_114: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term64.gamma_pow",
     "stage6.bytecode_read_raf.claim.term64.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_116: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_115: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_31",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_117: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_116: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term65.gamma_pow",
     "stage6.bytecode_read_raf.claim.term65.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_118: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_117: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_32",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_119: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_118: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term66.gamma_pow",
     "stage6.bytecode_read_raf.claim.term66.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_120: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_119: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_33",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_121: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_120: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term67.gamma_pow",
     "stage6.bytecode_read_raf.claim.term67.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_122: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_121: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_34",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_123: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_122: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term68.gamma_pow",
     "stage6.bytecode_read_raf.claim.term68.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_124: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_123: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_35",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_125: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_124: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term69.gamma_pow",
     "stage6.bytecode_read_raf.claim.term69.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_126: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_125: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_36",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_127: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_126: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term70.gamma_pow",
     "stage6.bytecode_read_raf.claim.term70.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_128: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_127: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_37",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_129: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_128: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term71.gamma_pow",
     "stage6.bytecode_read_raf.claim.term71.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_130: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_129: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_38",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_131: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_130: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term72.gamma_pow",
     "stage6.bytecode_read_raf.claim.term72.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_132: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_131: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_39",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_133: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_132: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term73.gamma_pow",
     "stage6.bytecode_read_raf.claim.term73.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_134: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_133: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow",
     "stage6.input.stage5.LookupTableFlag_40",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_135: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_134: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term74.gamma_pow",
     "stage6.bytecode_read_raf.claim.term74.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_136: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_135: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term75.gamma_pow",
     "stage6.input.stage1.PC",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_137: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_136: &[&str] = &[
     "stage6.bytecode_read_raf.claim.term76.gamma_pow",
     "stage6.input.stage3.spartan_shift.PC",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_138: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_137: &[&str] = &[
     "stage6.input.stage1.UnexpandedPC",
     "stage6.bytecode_read_raf.claim.term1.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_139: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_138: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial0",
     "stage6.bytecode_read_raf.claim.term2.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_140: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_139: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial1",
     "stage6.bytecode_read_raf.claim.term3.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_141: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_140: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial2",
     "stage6.bytecode_read_raf.claim.term4.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_142: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_141: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial3",
     "stage6.bytecode_read_raf.claim.term5.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_143: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_142: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial4",
     "stage6.bytecode_read_raf.claim.term6.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_144: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_143: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial5",
     "stage6.bytecode_read_raf.claim.term7.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_145: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_144: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial6",
     "stage6.bytecode_read_raf.claim.term8.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_146: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_145: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial7",
     "stage6.bytecode_read_raf.claim.term9.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_147: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_146: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial8",
     "stage6.bytecode_read_raf.claim.term10.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_148: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_147: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial9",
     "stage6.bytecode_read_raf.claim.term11.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_149: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_148: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial10",
     "stage6.bytecode_read_raf.claim.term12.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_150: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_149: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial11",
     "stage6.bytecode_read_raf.claim.term13.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_151: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_150: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial12",
     "stage6.bytecode_read_raf.claim.term14.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_152: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_151: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial13",
     "stage6.bytecode_read_raf.claim.term15.stage_gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_153: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_152: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial14",
     "stage6.bytecode_read_raf.claim.term16.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_154: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_153: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial15",
     "stage6.bytecode_read_raf.claim.term17.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_155: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_154: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial16",
     "stage6.bytecode_read_raf.claim.term18.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_156: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_155: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial17",
     "stage6.bytecode_read_raf.claim.term19.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_157: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_156: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial18",
     "stage6.bytecode_read_raf.claim.term20.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_158: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_157: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial19",
     "stage6.bytecode_read_raf.claim.term21.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_159: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_158: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial20",
     "stage6.bytecode_read_raf.claim.term22.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_160: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_159: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial21",
     "stage6.bytecode_read_raf.claim.term23.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_161: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_160: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial22",
     "stage6.bytecode_read_raf.claim.term24.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_162: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_161: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial23",
     "stage6.bytecode_read_raf.claim.term25.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_163: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_162: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial24",
     "stage6.bytecode_read_raf.claim.term26.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_164: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_163: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial25",
     "stage6.bytecode_read_raf.claim.term27.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_165: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_164: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial26",
     "stage6.bytecode_read_raf.claim.term28.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_166: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_165: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial27",
     "stage6.bytecode_read_raf.claim.term29.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_167: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_166: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial28",
     "stage6.bytecode_read_raf.claim.term30.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_168: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_167: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial29",
     "stage6.bytecode_read_raf.claim.term31.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_169: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_168: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial30",
     "stage6.bytecode_read_raf.claim.term32.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_170: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_169: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial31",
     "stage6.bytecode_read_raf.claim.term33.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_171: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_170: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial32",
     "stage6.bytecode_read_raf.claim.term34.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_172: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_171: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial33",
     "stage6.bytecode_read_raf.claim.term35.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_173: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_172: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial34",
     "stage6.bytecode_read_raf.claim.term36.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_174: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_173: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial35",
     "stage6.bytecode_read_raf.claim.term37.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_175: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_174: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial36",
     "stage6.bytecode_read_raf.claim.term38.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_176: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_175: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial37",
     "stage6.bytecode_read_raf.claim.term39.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_177: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_176: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial38",
     "stage6.bytecode_read_raf.claim.term40.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_178: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_177: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial39",
     "stage6.bytecode_read_raf.claim.term41.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_179: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_178: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial40",
     "stage6.bytecode_read_raf.claim.term42.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_180: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_179: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial41",
     "stage6.bytecode_read_raf.claim.term43.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_181: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_180: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial42",
     "stage6.bytecode_read_raf.claim.term44.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_182: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_181: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial43",
     "stage6.bytecode_read_raf.claim.term45.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_183: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_182: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial44",
     "stage6.bytecode_read_raf.claim.term46.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_184: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_183: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial45",
     "stage6.bytecode_read_raf.claim.term47.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_185: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_184: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial46",
     "stage6.bytecode_read_raf.claim.term48.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_186: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_185: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial47",
     "stage6.bytecode_read_raf.claim.term49.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_187: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_186: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial48",
     "stage6.bytecode_read_raf.claim.term50.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_188: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_187: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial49",
     "stage6.bytecode_read_raf.claim.term51.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_189: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_188: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial50",
     "stage6.bytecode_read_raf.claim.term52.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_190: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_189: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial51",
     "stage6.bytecode_read_raf.claim.term53.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_191: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_190: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial52",
     "stage6.bytecode_read_raf.claim.term54.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_192: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_191: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial53",
     "stage6.bytecode_read_raf.claim.term55.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_193: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_192: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial54",
     "stage6.bytecode_read_raf.claim.term56.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_194: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_193: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial55",
     "stage6.bytecode_read_raf.claim.term57.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_195: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_194: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial56",
     "stage6.bytecode_read_raf.claim.term58.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_196: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_195: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial57",
     "stage6.bytecode_read_raf.claim.term59.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_197: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_196: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial58",
     "stage6.bytecode_read_raf.claim.term60.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_198: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_197: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial59",
     "stage6.bytecode_read_raf.claim.term61.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_199: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_198: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial60",
     "stage6.bytecode_read_raf.claim.term62.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_200: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_199: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial61",
     "stage6.bytecode_read_raf.claim.term63.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_201: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_200: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial62",
     "stage6.bytecode_read_raf.claim.term64.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_202: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_201: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial63",
     "stage6.bytecode_read_raf.claim.term65.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_203: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_202: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial64",
     "stage6.bytecode_read_raf.claim.term66.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_204: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_203: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial65",
     "stage6.bytecode_read_raf.claim.term67.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_205: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_204: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial66",
     "stage6.bytecode_read_raf.claim.term68.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_206: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_205: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial67",
     "stage6.bytecode_read_raf.claim.term69.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_207: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_206: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial68",
     "stage6.bytecode_read_raf.claim.term70.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_208: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_207: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial69",
     "stage6.bytecode_read_raf.claim.term71.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_209: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_208: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial70",
     "stage6.bytecode_read_raf.claim.term72.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_210: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_209: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial71",
     "stage6.bytecode_read_raf.claim.term73.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_211: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_210: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial72",
     "stage6.bytecode_read_raf.claim.term74.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_212: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_211: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial73",
     "stage6.bytecode_read_raf.claim.term75.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_213: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_212: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial74",
     "stage6.bytecode_read_raf.claim.term76.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_214: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_213: &[&str] = &[
     "stage6.bytecode_read_raf.claim_expr.partial75",
     "stage6.bytecode_read_raf.claim.entry_constant",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_215: &[&str] = &["stage6.instruction_ra_virtual.gamma"];
+pub const STAGE6_FIELD_EXPR_OPERANDS_214: &[&str] = &["stage6.instruction_ra_virtual.gamma"];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_216: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_215: &[&str] = &[
     "stage6.instruction_ra_virtual.claim.term1.gamma_pow",
     "stage6.input.stage5.instruction_read_raf.InstructionRa_1",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_217: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_216: &[&str] = &[
     "stage6.instruction_ra_virtual.claim.term2.gamma_pow",
     "stage6.input.stage5.instruction_read_raf.InstructionRa_2",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_218: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_217: &[&str] = &[
     "stage6.instruction_ra_virtual.claim.term3.gamma_pow",
     "stage6.input.stage5.instruction_read_raf.InstructionRa_3",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_219: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_218: &[&str] = &[
     "stage6.instruction_ra_virtual.claim.term4.gamma_pow",
     "stage6.input.stage5.instruction_read_raf.InstructionRa_4",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_220: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_219: &[&str] = &[
     "stage6.instruction_ra_virtual.claim.term5.gamma_pow",
     "stage6.input.stage5.instruction_read_raf.InstructionRa_5",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_221: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_220: &[&str] = &[
     "stage6.instruction_ra_virtual.claim.term6.gamma_pow",
     "stage6.input.stage5.instruction_read_raf.InstructionRa_6",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_222: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_221: &[&str] = &[
     "stage6.instruction_ra_virtual.claim.term7.gamma_pow",
     "stage6.input.stage5.instruction_read_raf.InstructionRa_7",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_223: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_222: &[&str] = &[
     "stage6.input.stage5.instruction_read_raf.InstructionRa_0",
     "stage6.instruction_ra_virtual.claim.term1.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_224: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_223: &[&str] = &[
     "stage6.instruction_ra_virtual.claim_expr.partial0",
     "stage6.instruction_ra_virtual.claim.term2.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_225: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_224: &[&str] = &[
     "stage6.instruction_ra_virtual.claim_expr.partial1",
     "stage6.instruction_ra_virtual.claim.term3.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_226: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_225: &[&str] = &[
     "stage6.instruction_ra_virtual.claim_expr.partial2",
     "stage6.instruction_ra_virtual.claim.term4.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_227: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_226: &[&str] = &[
     "stage6.instruction_ra_virtual.claim_expr.partial3",
     "stage6.instruction_ra_virtual.claim.term5.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_228: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_227: &[&str] = &[
     "stage6.instruction_ra_virtual.claim_expr.partial4",
     "stage6.instruction_ra_virtual.claim.term6.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_229: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_228: &[&str] = &[
     "stage6.instruction_ra_virtual.claim_expr.partial5",
     "stage6.instruction_ra_virtual.claim.term7.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_230: &[&str] = &["stage6.inc_claim_reduction.gamma"];
+pub const STAGE6_FIELD_EXPR_OPERANDS_229: &[&str] = &["stage6.inc_claim_reduction.gamma"];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_231: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_230: &[&str] = &[
     "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow",
     "stage6.input.stage4.ram_val_check.RamInc",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_232: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_231: &[&str] = &[
     "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow",
     "stage6.input.stage4.registers_read_write.RdInc",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_233: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_232: &[&str] = &[
     "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow",
     "stage6.input.stage5.registers_val_evaluation.RdInc",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_234: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_233: &[&str] = &[
     "stage6.input.stage2.ram_read_write.RamInc",
     "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_235: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_234: &[&str] = &[
     "stage6.inc_claim_reduction.claim_expr.partial0",
     "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term",
 ];
 
-pub const STAGE6_FIELD_EXPR_OPERANDS_236: &[&str] = &[
+pub const STAGE6_FIELD_EXPR_OPERANDS_235: &[&str] = &[
     "stage6.inc_claim_reduction.claim_expr.partial1",
     "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term",
 ];
 
 pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_0", kind: "op", formula: "field.pow:0", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_1", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_2", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_3", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_4", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_5", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_6", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_7", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_8", kind: "op", formula: "field.pow:16", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_9", kind: "op", formula: "field.pow:18", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_10", kind: "op", formula: "field.pow:20", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_11", kind: "op", formula: "field.pow:22", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_12", kind: "op", formula: "field.pow:24", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_13", kind: "op", formula: "field.pow:26", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_14", kind: "op", formula: "field.pow:28", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_15", kind: "op", formula: "field.pow:30", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_16", kind: "op", formula: "field.pow:32", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_17", kind: "op", formula: "field.pow:34", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_18", kind: "op", formula: "field.pow:36", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_19", kind: "op", formula: "field.pow:38", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_20", kind: "op", formula: "field.pow:40", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_21", kind: "op", formula: "field.pow:42", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_22", kind: "op", formula: "field.pow:44", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_23", kind: "op", formula: "field.pow:46", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_24", kind: "op", formula: "field.pow:48", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_25", kind: "op", formula: "field.pow:50", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_26", kind: "op", formula: "field.pow:52", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_27", kind: "op", formula: "field.pow:54", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_28", kind: "op", formula: "field.pow:56", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_29", kind: "op", formula: "field.pow:58", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_30", kind: "op", formula: "field.pow:60", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_31", kind: "op", formula: "field.pow:62", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_32", kind: "op", formula: "field.pow:64", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_33", kind: "op", formula: "field.pow:66", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_34", kind: "op", formula: "field.pow:68", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_35", kind: "op", formula: "field.pow:70", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_36", kind: "op", formula: "field.pow:72", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_37", kind: "op", formula: "field.pow:74", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_38", kind: "op", formula: "field.pow:76", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_0", kind: "op", formula: "field.pow:0", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_1", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_2", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_3", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_4", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_5", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_6", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_7", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_8", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_9", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_10", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_11", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_12", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_13", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_14", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_15", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_16", kind: "op", formula: "field.pow:16", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_17", kind: "op", formula: "field.pow:17", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_18", kind: "op", formula: "field.pow:18", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_19", kind: "op", formula: "field.pow:19", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_20", kind: "op", formula: "field.pow:20", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_21", kind: "op", formula: "field.pow:21", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_22", kind: "op", formula: "field.pow:22", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_23", kind: "op", formula: "field.pow:23", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_24", kind: "op", formula: "field.pow:24", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_25", kind: "op", formula: "field.pow:25", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_26", kind: "op", formula: "field.pow:26", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_27", kind: "op", formula: "field.pow:27", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_28", kind: "op", formula: "field.pow:28", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_29", kind: "op", formula: "field.pow:29", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_30", kind: "op", formula: "field.pow:30", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_31", kind: "op", formula: "field.pow:31", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_32", kind: "op", formula: "field.pow:32", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_33", kind: "op", formula: "field.pow:33", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_34", kind: "op", formula: "field.pow:34", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_35", kind: "op", formula: "field.pow:35", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_36", kind: "op", formula: "field.pow:36", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_37", kind: "op", formula: "field.pow:37", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_38", kind: "op", formula: "field.pow:38", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term1.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_2, operands: STAGE6_FIELD_EXPR_OPERANDS_2 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term2.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_3, operands: STAGE6_FIELD_EXPR_OPERANDS_3 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term3.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_4, operands: STAGE6_FIELD_EXPR_OPERANDS_4 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term4.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_5, operands: STAGE6_FIELD_EXPR_OPERANDS_5 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term5.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_6, operands: STAGE6_FIELD_EXPR_OPERANDS_6 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term6.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_7, operands: STAGE6_FIELD_EXPR_OPERANDS_7 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term7.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_8, operands: STAGE6_FIELD_EXPR_OPERANDS_8 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term8.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_9, operands: STAGE6_FIELD_EXPR_OPERANDS_9 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term9.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_10, operands: STAGE6_FIELD_EXPR_OPERANDS_10 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term10.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_11, operands: STAGE6_FIELD_EXPR_OPERANDS_11 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term11.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_12, operands: STAGE6_FIELD_EXPR_OPERANDS_12 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term12.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_13, operands: STAGE6_FIELD_EXPR_OPERANDS_13 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term13.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_14, operands: STAGE6_FIELD_EXPR_OPERANDS_14 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term14.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_15, operands: STAGE6_FIELD_EXPR_OPERANDS_15 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term15.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term16.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term16.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_18, operands: STAGE6_FIELD_EXPR_OPERANDS_18 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_19, operands: STAGE6_FIELD_EXPR_OPERANDS_19 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_20, operands: STAGE6_FIELD_EXPR_OPERANDS_20 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_21, operands: STAGE6_FIELD_EXPR_OPERANDS_21 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_19, operands: STAGE6_FIELD_EXPR_OPERANDS_19 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_22, operands: STAGE6_FIELD_EXPR_OPERANDS_22 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_23, operands: STAGE6_FIELD_EXPR_OPERANDS_23 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_19, operands: STAGE6_FIELD_EXPR_OPERANDS_19 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_24, operands: STAGE6_FIELD_EXPR_OPERANDS_24 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_25, operands: STAGE6_FIELD_EXPR_OPERANDS_25 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term20.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term20.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_28, operands: STAGE6_FIELD_EXPR_OPERANDS_28 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_29, operands: STAGE6_FIELD_EXPR_OPERANDS_29 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_30, operands: STAGE6_FIELD_EXPR_OPERANDS_30 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_31, operands: STAGE6_FIELD_EXPR_OPERANDS_31 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_32, operands: STAGE6_FIELD_EXPR_OPERANDS_32 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_33, operands: STAGE6_FIELD_EXPR_OPERANDS_33 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_34, operands: STAGE6_FIELD_EXPR_OPERANDS_34 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_35, operands: STAGE6_FIELD_EXPR_OPERANDS_35 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_36, operands: STAGE6_FIELD_EXPR_OPERANDS_36 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_37, operands: STAGE6_FIELD_EXPR_OPERANDS_37 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_38, operands: STAGE6_FIELD_EXPR_OPERANDS_38 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_39, operands: STAGE6_FIELD_EXPR_OPERANDS_39 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_40, operands: STAGE6_FIELD_EXPR_OPERANDS_40 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_41, operands: STAGE6_FIELD_EXPR_OPERANDS_41 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_42, operands: STAGE6_FIELD_EXPR_OPERANDS_42 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_43, operands: STAGE6_FIELD_EXPR_OPERANDS_43 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term29.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term29.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_44, operands: STAGE6_FIELD_EXPR_OPERANDS_44 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_45, operands: STAGE6_FIELD_EXPR_OPERANDS_45 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_46, operands: STAGE6_FIELD_EXPR_OPERANDS_46 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_47, operands: STAGE6_FIELD_EXPR_OPERANDS_47 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_45, operands: STAGE6_FIELD_EXPR_OPERANDS_45 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_48, operands: STAGE6_FIELD_EXPR_OPERANDS_48 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_49, operands: STAGE6_FIELD_EXPR_OPERANDS_49 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term32.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term32.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_52, operands: STAGE6_FIELD_EXPR_OPERANDS_52 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_53, operands: STAGE6_FIELD_EXPR_OPERANDS_53 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_54, operands: STAGE6_FIELD_EXPR_OPERANDS_54 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_55, operands: STAGE6_FIELD_EXPR_OPERANDS_55 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_56, operands: STAGE6_FIELD_EXPR_OPERANDS_56 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_57, operands: STAGE6_FIELD_EXPR_OPERANDS_57 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_58, operands: STAGE6_FIELD_EXPR_OPERANDS_58 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_59, operands: STAGE6_FIELD_EXPR_OPERANDS_59 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_60, operands: STAGE6_FIELD_EXPR_OPERANDS_60 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_61, operands: STAGE6_FIELD_EXPR_OPERANDS_61 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_62, operands: STAGE6_FIELD_EXPR_OPERANDS_62 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_63, operands: STAGE6_FIELD_EXPR_OPERANDS_63 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_64, operands: STAGE6_FIELD_EXPR_OPERANDS_64 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_65, operands: STAGE6_FIELD_EXPR_OPERANDS_65 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_66, operands: STAGE6_FIELD_EXPR_OPERANDS_66 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_67, operands: STAGE6_FIELD_EXPR_OPERANDS_67 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_68, operands: STAGE6_FIELD_EXPR_OPERANDS_68 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_69, operands: STAGE6_FIELD_EXPR_OPERANDS_69 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_70, operands: STAGE6_FIELD_EXPR_OPERANDS_70 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_71, operands: STAGE6_FIELD_EXPR_OPERANDS_71 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_72, operands: STAGE6_FIELD_EXPR_OPERANDS_72 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_73, operands: STAGE6_FIELD_EXPR_OPERANDS_73 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_74, operands: STAGE6_FIELD_EXPR_OPERANDS_74 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_75, operands: STAGE6_FIELD_EXPR_OPERANDS_75 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_76, operands: STAGE6_FIELD_EXPR_OPERANDS_76 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_77, operands: STAGE6_FIELD_EXPR_OPERANDS_77 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_78, operands: STAGE6_FIELD_EXPR_OPERANDS_78 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_79, operands: STAGE6_FIELD_EXPR_OPERANDS_79 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_80, operands: STAGE6_FIELD_EXPR_OPERANDS_80 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_81, operands: STAGE6_FIELD_EXPR_OPERANDS_81 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", kind: "op", formula: "field.pow:16", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_82, operands: STAGE6_FIELD_EXPR_OPERANDS_82 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_83, operands: STAGE6_FIELD_EXPR_OPERANDS_83 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", kind: "op", formula: "field.pow:17", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_84, operands: STAGE6_FIELD_EXPR_OPERANDS_84 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_85, operands: STAGE6_FIELD_EXPR_OPERANDS_85 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", kind: "op", formula: "field.pow:18", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_86, operands: STAGE6_FIELD_EXPR_OPERANDS_86 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_87, operands: STAGE6_FIELD_EXPR_OPERANDS_87 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", kind: "op", formula: "field.pow:19", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_88, operands: STAGE6_FIELD_EXPR_OPERANDS_88 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_89, operands: STAGE6_FIELD_EXPR_OPERANDS_89 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", kind: "op", formula: "field.pow:20", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_90, operands: STAGE6_FIELD_EXPR_OPERANDS_90 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_91, operands: STAGE6_FIELD_EXPR_OPERANDS_91 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", kind: "op", formula: "field.pow:21", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_92, operands: STAGE6_FIELD_EXPR_OPERANDS_92 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_93, operands: STAGE6_FIELD_EXPR_OPERANDS_93 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", kind: "op", formula: "field.pow:22", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_94, operands: STAGE6_FIELD_EXPR_OPERANDS_94 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_95, operands: STAGE6_FIELD_EXPR_OPERANDS_95 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", kind: "op", formula: "field.pow:23", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_96, operands: STAGE6_FIELD_EXPR_OPERANDS_96 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_97, operands: STAGE6_FIELD_EXPR_OPERANDS_97 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", kind: "op", formula: "field.pow:24", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_98, operands: STAGE6_FIELD_EXPR_OPERANDS_98 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_99, operands: STAGE6_FIELD_EXPR_OPERANDS_99 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", kind: "op", formula: "field.pow:25", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_100, operands: STAGE6_FIELD_EXPR_OPERANDS_100 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_101, operands: STAGE6_FIELD_EXPR_OPERANDS_101 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", kind: "op", formula: "field.pow:26", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_102, operands: STAGE6_FIELD_EXPR_OPERANDS_102 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_103, operands: STAGE6_FIELD_EXPR_OPERANDS_103 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", kind: "op", formula: "field.pow:27", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_104, operands: STAGE6_FIELD_EXPR_OPERANDS_104 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_105, operands: STAGE6_FIELD_EXPR_OPERANDS_105 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", kind: "op", formula: "field.pow:28", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_106, operands: STAGE6_FIELD_EXPR_OPERANDS_106 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_107, operands: STAGE6_FIELD_EXPR_OPERANDS_107 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", kind: "op", formula: "field.pow:29", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_108, operands: STAGE6_FIELD_EXPR_OPERANDS_108 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_109, operands: STAGE6_FIELD_EXPR_OPERANDS_109 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", kind: "op", formula: "field.pow:30", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_110, operands: STAGE6_FIELD_EXPR_OPERANDS_110 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_111, operands: STAGE6_FIELD_EXPR_OPERANDS_111 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", kind: "op", formula: "field.pow:31", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_112, operands: STAGE6_FIELD_EXPR_OPERANDS_112 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_113, operands: STAGE6_FIELD_EXPR_OPERANDS_113 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", kind: "op", formula: "field.pow:32", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_114, operands: STAGE6_FIELD_EXPR_OPERANDS_114 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_115, operands: STAGE6_FIELD_EXPR_OPERANDS_115 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", kind: "op", formula: "field.pow:33", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_116, operands: STAGE6_FIELD_EXPR_OPERANDS_116 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_117, operands: STAGE6_FIELD_EXPR_OPERANDS_117 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", kind: "op", formula: "field.pow:34", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_118, operands: STAGE6_FIELD_EXPR_OPERANDS_118 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_119, operands: STAGE6_FIELD_EXPR_OPERANDS_119 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", kind: "op", formula: "field.pow:35", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_120, operands: STAGE6_FIELD_EXPR_OPERANDS_120 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_121, operands: STAGE6_FIELD_EXPR_OPERANDS_121 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", kind: "op", formula: "field.pow:36", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_122, operands: STAGE6_FIELD_EXPR_OPERANDS_122 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_123, operands: STAGE6_FIELD_EXPR_OPERANDS_123 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", kind: "op", formula: "field.pow:37", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_124, operands: STAGE6_FIELD_EXPR_OPERANDS_124 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_125, operands: STAGE6_FIELD_EXPR_OPERANDS_125 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", kind: "op", formula: "field.pow:38", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_126, operands: STAGE6_FIELD_EXPR_OPERANDS_126 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_127, operands: STAGE6_FIELD_EXPR_OPERANDS_127 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", kind: "op", formula: "field.pow:39", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_128, operands: STAGE6_FIELD_EXPR_OPERANDS_128 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_129, operands: STAGE6_FIELD_EXPR_OPERANDS_129 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", kind: "op", formula: "field.pow:40", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_130, operands: STAGE6_FIELD_EXPR_OPERANDS_130 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_131, operands: STAGE6_FIELD_EXPR_OPERANDS_131 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", kind: "op", formula: "field.pow:41", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_132, operands: STAGE6_FIELD_EXPR_OPERANDS_132 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_133, operands: STAGE6_FIELD_EXPR_OPERANDS_133 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", kind: "op", formula: "field.pow:42", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_134, operands: STAGE6_FIELD_EXPR_OPERANDS_134 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_135, operands: STAGE6_FIELD_EXPR_OPERANDS_135 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term75.gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term75.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_136, operands: STAGE6_FIELD_EXPR_OPERANDS_136 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term76.gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term76.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_137, operands: STAGE6_FIELD_EXPR_OPERANDS_137 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.entry_constant", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_138, operands: STAGE6_FIELD_EXPR_OPERANDS_138 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_139, operands: STAGE6_FIELD_EXPR_OPERANDS_139 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_140, operands: STAGE6_FIELD_EXPR_OPERANDS_140 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial3", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_141, operands: STAGE6_FIELD_EXPR_OPERANDS_141 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial4", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_142, operands: STAGE6_FIELD_EXPR_OPERANDS_142 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial5", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_143, operands: STAGE6_FIELD_EXPR_OPERANDS_143 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial6", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_144, operands: STAGE6_FIELD_EXPR_OPERANDS_144 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial7", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_145, operands: STAGE6_FIELD_EXPR_OPERANDS_145 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial8", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_146, operands: STAGE6_FIELD_EXPR_OPERANDS_146 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial9", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_147, operands: STAGE6_FIELD_EXPR_OPERANDS_147 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial10", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_148, operands: STAGE6_FIELD_EXPR_OPERANDS_148 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial11", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_149, operands: STAGE6_FIELD_EXPR_OPERANDS_149 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial12", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_150, operands: STAGE6_FIELD_EXPR_OPERANDS_150 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial13", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_151, operands: STAGE6_FIELD_EXPR_OPERANDS_151 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial14", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_152, operands: STAGE6_FIELD_EXPR_OPERANDS_152 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial15", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_153, operands: STAGE6_FIELD_EXPR_OPERANDS_153 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial16", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_154, operands: STAGE6_FIELD_EXPR_OPERANDS_154 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial17", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_155, operands: STAGE6_FIELD_EXPR_OPERANDS_155 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial18", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_156, operands: STAGE6_FIELD_EXPR_OPERANDS_156 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial19", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_157, operands: STAGE6_FIELD_EXPR_OPERANDS_157 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial20", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_158, operands: STAGE6_FIELD_EXPR_OPERANDS_158 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial21", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_159, operands: STAGE6_FIELD_EXPR_OPERANDS_159 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial22", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_160, operands: STAGE6_FIELD_EXPR_OPERANDS_160 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial23", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_161, operands: STAGE6_FIELD_EXPR_OPERANDS_161 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial24", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_162, operands: STAGE6_FIELD_EXPR_OPERANDS_162 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial25", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_163, operands: STAGE6_FIELD_EXPR_OPERANDS_163 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial26", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_164, operands: STAGE6_FIELD_EXPR_OPERANDS_164 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial27", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_165, operands: STAGE6_FIELD_EXPR_OPERANDS_165 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial28", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_166, operands: STAGE6_FIELD_EXPR_OPERANDS_166 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial29", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_167, operands: STAGE6_FIELD_EXPR_OPERANDS_167 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial30", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_168, operands: STAGE6_FIELD_EXPR_OPERANDS_168 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial31", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_169, operands: STAGE6_FIELD_EXPR_OPERANDS_169 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial32", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_170, operands: STAGE6_FIELD_EXPR_OPERANDS_170 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial33", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_171, operands: STAGE6_FIELD_EXPR_OPERANDS_171 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial34", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_172, operands: STAGE6_FIELD_EXPR_OPERANDS_172 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial35", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_173, operands: STAGE6_FIELD_EXPR_OPERANDS_173 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial36", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_174, operands: STAGE6_FIELD_EXPR_OPERANDS_174 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial37", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_175, operands: STAGE6_FIELD_EXPR_OPERANDS_175 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial38", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_176, operands: STAGE6_FIELD_EXPR_OPERANDS_176 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial39", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_177, operands: STAGE6_FIELD_EXPR_OPERANDS_177 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial40", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_178, operands: STAGE6_FIELD_EXPR_OPERANDS_178 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial41", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_179, operands: STAGE6_FIELD_EXPR_OPERANDS_179 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial42", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_180, operands: STAGE6_FIELD_EXPR_OPERANDS_180 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial43", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_181, operands: STAGE6_FIELD_EXPR_OPERANDS_181 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial44", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_182, operands: STAGE6_FIELD_EXPR_OPERANDS_182 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial45", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_183, operands: STAGE6_FIELD_EXPR_OPERANDS_183 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial46", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_184, operands: STAGE6_FIELD_EXPR_OPERANDS_184 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial47", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_185, operands: STAGE6_FIELD_EXPR_OPERANDS_185 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial48", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_186, operands: STAGE6_FIELD_EXPR_OPERANDS_186 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial49", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_187, operands: STAGE6_FIELD_EXPR_OPERANDS_187 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial50", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_188, operands: STAGE6_FIELD_EXPR_OPERANDS_188 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial51", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_189, operands: STAGE6_FIELD_EXPR_OPERANDS_189 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial52", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_190, operands: STAGE6_FIELD_EXPR_OPERANDS_190 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial53", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_191, operands: STAGE6_FIELD_EXPR_OPERANDS_191 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial54", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_192, operands: STAGE6_FIELD_EXPR_OPERANDS_192 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial55", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_193, operands: STAGE6_FIELD_EXPR_OPERANDS_193 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial56", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_194, operands: STAGE6_FIELD_EXPR_OPERANDS_194 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial57", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_195, operands: STAGE6_FIELD_EXPR_OPERANDS_195 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial58", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_196, operands: STAGE6_FIELD_EXPR_OPERANDS_196 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial59", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_197, operands: STAGE6_FIELD_EXPR_OPERANDS_197 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial60", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_198, operands: STAGE6_FIELD_EXPR_OPERANDS_198 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial61", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_199, operands: STAGE6_FIELD_EXPR_OPERANDS_199 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial62", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_200, operands: STAGE6_FIELD_EXPR_OPERANDS_200 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial63", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_201, operands: STAGE6_FIELD_EXPR_OPERANDS_201 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial64", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_202, operands: STAGE6_FIELD_EXPR_OPERANDS_202 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial65", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_203, operands: STAGE6_FIELD_EXPR_OPERANDS_203 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial66", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_204, operands: STAGE6_FIELD_EXPR_OPERANDS_204 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial67", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_205, operands: STAGE6_FIELD_EXPR_OPERANDS_205 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial68", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_206, operands: STAGE6_FIELD_EXPR_OPERANDS_206 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial69", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_207, operands: STAGE6_FIELD_EXPR_OPERANDS_207 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial70", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_208, operands: STAGE6_FIELD_EXPR_OPERANDS_208 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial71", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_209, operands: STAGE6_FIELD_EXPR_OPERANDS_209 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial72", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_210, operands: STAGE6_FIELD_EXPR_OPERANDS_210 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial73", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_211, operands: STAGE6_FIELD_EXPR_OPERANDS_211 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial74", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_212, operands: STAGE6_FIELD_EXPR_OPERANDS_212 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial75", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_213, operands: STAGE6_FIELD_EXPR_OPERANDS_213 },
-    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial76", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term1.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term1.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_216, operands: STAGE6_FIELD_EXPR_OPERANDS_216 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term2.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term2.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_217, operands: STAGE6_FIELD_EXPR_OPERANDS_217 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term3.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term3.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_218, operands: STAGE6_FIELD_EXPR_OPERANDS_218 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term4.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_219, operands: STAGE6_FIELD_EXPR_OPERANDS_219 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term5.gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term5.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_220, operands: STAGE6_FIELD_EXPR_OPERANDS_220 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term6.gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term6.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_221, operands: STAGE6_FIELD_EXPR_OPERANDS_221 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term7.gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term7.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_222, operands: STAGE6_FIELD_EXPR_OPERANDS_222 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_223, operands: STAGE6_FIELD_EXPR_OPERANDS_223 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_224, operands: STAGE6_FIELD_EXPR_OPERANDS_224 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_225, operands: STAGE6_FIELD_EXPR_OPERANDS_225 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial3", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_226, operands: STAGE6_FIELD_EXPR_OPERANDS_226 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial4", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_227, operands: STAGE6_FIELD_EXPR_OPERANDS_227 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial5", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_228, operands: STAGE6_FIELD_EXPR_OPERANDS_228 },
-    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial6", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_229, operands: STAGE6_FIELD_EXPR_OPERANDS_229 },
-    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_230, operands: STAGE6_FIELD_EXPR_OPERANDS_230 },
-    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_231, operands: STAGE6_FIELD_EXPR_OPERANDS_231 },
-    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_230, operands: STAGE6_FIELD_EXPR_OPERANDS_230 },
-    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_232, operands: STAGE6_FIELD_EXPR_OPERANDS_232 },
-    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_230, operands: STAGE6_FIELD_EXPR_OPERANDS_230 },
-    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_233, operands: STAGE6_FIELD_EXPR_OPERANDS_233 },
-    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_234, operands: STAGE6_FIELD_EXPR_OPERANDS_234 },
-    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_235, operands: STAGE6_FIELD_EXPR_OPERANDS_235 },
-    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_236, operands: STAGE6_FIELD_EXPR_OPERANDS_236 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term1.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term2.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_2, operands: STAGE6_FIELD_EXPR_OPERANDS_2 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term3.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_3, operands: STAGE6_FIELD_EXPR_OPERANDS_3 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term4.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_4, operands: STAGE6_FIELD_EXPR_OPERANDS_4 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term5.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_5, operands: STAGE6_FIELD_EXPR_OPERANDS_5 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term6.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_6, operands: STAGE6_FIELD_EXPR_OPERANDS_6 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term7.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_7, operands: STAGE6_FIELD_EXPR_OPERANDS_7 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term8.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_8, operands: STAGE6_FIELD_EXPR_OPERANDS_8 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term9.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_9, operands: STAGE6_FIELD_EXPR_OPERANDS_9 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term10.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_10, operands: STAGE6_FIELD_EXPR_OPERANDS_10 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term11.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_11, operands: STAGE6_FIELD_EXPR_OPERANDS_11 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term12.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_12, operands: STAGE6_FIELD_EXPR_OPERANDS_12 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term13.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_13, operands: STAGE6_FIELD_EXPR_OPERANDS_13 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term14.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_14, operands: STAGE6_FIELD_EXPR_OPERANDS_14 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term15.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_15, operands: STAGE6_FIELD_EXPR_OPERANDS_15 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term16.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term16.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_18, operands: STAGE6_FIELD_EXPR_OPERANDS_18 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_19, operands: STAGE6_FIELD_EXPR_OPERANDS_19 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_20, operands: STAGE6_FIELD_EXPR_OPERANDS_20 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_18, operands: STAGE6_FIELD_EXPR_OPERANDS_18 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_21, operands: STAGE6_FIELD_EXPR_OPERANDS_21 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_22, operands: STAGE6_FIELD_EXPR_OPERANDS_22 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_18, operands: STAGE6_FIELD_EXPR_OPERANDS_18 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_23, operands: STAGE6_FIELD_EXPR_OPERANDS_23 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_24, operands: STAGE6_FIELD_EXPR_OPERANDS_24 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term20.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term20.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_25, operands: STAGE6_FIELD_EXPR_OPERANDS_25 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_28, operands: STAGE6_FIELD_EXPR_OPERANDS_28 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_29, operands: STAGE6_FIELD_EXPR_OPERANDS_29 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_30, operands: STAGE6_FIELD_EXPR_OPERANDS_30 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_31, operands: STAGE6_FIELD_EXPR_OPERANDS_31 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_32, operands: STAGE6_FIELD_EXPR_OPERANDS_32 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_33, operands: STAGE6_FIELD_EXPR_OPERANDS_33 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_34, operands: STAGE6_FIELD_EXPR_OPERANDS_34 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_35, operands: STAGE6_FIELD_EXPR_OPERANDS_35 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_36, operands: STAGE6_FIELD_EXPR_OPERANDS_36 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_37, operands: STAGE6_FIELD_EXPR_OPERANDS_37 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_38, operands: STAGE6_FIELD_EXPR_OPERANDS_38 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_39, operands: STAGE6_FIELD_EXPR_OPERANDS_39 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_40, operands: STAGE6_FIELD_EXPR_OPERANDS_40 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_41, operands: STAGE6_FIELD_EXPR_OPERANDS_41 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_42, operands: STAGE6_FIELD_EXPR_OPERANDS_42 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term29.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term29.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_43, operands: STAGE6_FIELD_EXPR_OPERANDS_43 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_44, operands: STAGE6_FIELD_EXPR_OPERANDS_44 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_45, operands: STAGE6_FIELD_EXPR_OPERANDS_45 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_46, operands: STAGE6_FIELD_EXPR_OPERANDS_46 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_44, operands: STAGE6_FIELD_EXPR_OPERANDS_44 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_47, operands: STAGE6_FIELD_EXPR_OPERANDS_47 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_48, operands: STAGE6_FIELD_EXPR_OPERANDS_48 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term32.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term32.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_49, operands: STAGE6_FIELD_EXPR_OPERANDS_49 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_52, operands: STAGE6_FIELD_EXPR_OPERANDS_52 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_53, operands: STAGE6_FIELD_EXPR_OPERANDS_53 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_54, operands: STAGE6_FIELD_EXPR_OPERANDS_54 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_55, operands: STAGE6_FIELD_EXPR_OPERANDS_55 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_56, operands: STAGE6_FIELD_EXPR_OPERANDS_56 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_57, operands: STAGE6_FIELD_EXPR_OPERANDS_57 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_58, operands: STAGE6_FIELD_EXPR_OPERANDS_58 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_59, operands: STAGE6_FIELD_EXPR_OPERANDS_59 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_60, operands: STAGE6_FIELD_EXPR_OPERANDS_60 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_61, operands: STAGE6_FIELD_EXPR_OPERANDS_61 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_62, operands: STAGE6_FIELD_EXPR_OPERANDS_62 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_63, operands: STAGE6_FIELD_EXPR_OPERANDS_63 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_64, operands: STAGE6_FIELD_EXPR_OPERANDS_64 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_65, operands: STAGE6_FIELD_EXPR_OPERANDS_65 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_66, operands: STAGE6_FIELD_EXPR_OPERANDS_66 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_67, operands: STAGE6_FIELD_EXPR_OPERANDS_67 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_68, operands: STAGE6_FIELD_EXPR_OPERANDS_68 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_69, operands: STAGE6_FIELD_EXPR_OPERANDS_69 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_70, operands: STAGE6_FIELD_EXPR_OPERANDS_70 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_71, operands: STAGE6_FIELD_EXPR_OPERANDS_71 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_72, operands: STAGE6_FIELD_EXPR_OPERANDS_72 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_73, operands: STAGE6_FIELD_EXPR_OPERANDS_73 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_74, operands: STAGE6_FIELD_EXPR_OPERANDS_74 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_75, operands: STAGE6_FIELD_EXPR_OPERANDS_75 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_76, operands: STAGE6_FIELD_EXPR_OPERANDS_76 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_77, operands: STAGE6_FIELD_EXPR_OPERANDS_77 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_78, operands: STAGE6_FIELD_EXPR_OPERANDS_78 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_79, operands: STAGE6_FIELD_EXPR_OPERANDS_79 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_80, operands: STAGE6_FIELD_EXPR_OPERANDS_80 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", kind: "op", formula: "field.pow:16", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_81, operands: STAGE6_FIELD_EXPR_OPERANDS_81 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_82, operands: STAGE6_FIELD_EXPR_OPERANDS_82 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", kind: "op", formula: "field.pow:17", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_83, operands: STAGE6_FIELD_EXPR_OPERANDS_83 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_84, operands: STAGE6_FIELD_EXPR_OPERANDS_84 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", kind: "op", formula: "field.pow:18", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_85, operands: STAGE6_FIELD_EXPR_OPERANDS_85 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_86, operands: STAGE6_FIELD_EXPR_OPERANDS_86 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", kind: "op", formula: "field.pow:19", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_87, operands: STAGE6_FIELD_EXPR_OPERANDS_87 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_88, operands: STAGE6_FIELD_EXPR_OPERANDS_88 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", kind: "op", formula: "field.pow:20", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_89, operands: STAGE6_FIELD_EXPR_OPERANDS_89 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_90, operands: STAGE6_FIELD_EXPR_OPERANDS_90 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", kind: "op", formula: "field.pow:21", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_91, operands: STAGE6_FIELD_EXPR_OPERANDS_91 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_92, operands: STAGE6_FIELD_EXPR_OPERANDS_92 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", kind: "op", formula: "field.pow:22", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_93, operands: STAGE6_FIELD_EXPR_OPERANDS_93 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_94, operands: STAGE6_FIELD_EXPR_OPERANDS_94 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", kind: "op", formula: "field.pow:23", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_95, operands: STAGE6_FIELD_EXPR_OPERANDS_95 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_96, operands: STAGE6_FIELD_EXPR_OPERANDS_96 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", kind: "op", formula: "field.pow:24", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_97, operands: STAGE6_FIELD_EXPR_OPERANDS_97 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_98, operands: STAGE6_FIELD_EXPR_OPERANDS_98 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", kind: "op", formula: "field.pow:25", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_99, operands: STAGE6_FIELD_EXPR_OPERANDS_99 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_100, operands: STAGE6_FIELD_EXPR_OPERANDS_100 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", kind: "op", formula: "field.pow:26", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_101, operands: STAGE6_FIELD_EXPR_OPERANDS_101 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_102, operands: STAGE6_FIELD_EXPR_OPERANDS_102 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", kind: "op", formula: "field.pow:27", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_103, operands: STAGE6_FIELD_EXPR_OPERANDS_103 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_104, operands: STAGE6_FIELD_EXPR_OPERANDS_104 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", kind: "op", formula: "field.pow:28", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_105, operands: STAGE6_FIELD_EXPR_OPERANDS_105 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_106, operands: STAGE6_FIELD_EXPR_OPERANDS_106 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", kind: "op", formula: "field.pow:29", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_107, operands: STAGE6_FIELD_EXPR_OPERANDS_107 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_108, operands: STAGE6_FIELD_EXPR_OPERANDS_108 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", kind: "op", formula: "field.pow:30", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_109, operands: STAGE6_FIELD_EXPR_OPERANDS_109 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_110, operands: STAGE6_FIELD_EXPR_OPERANDS_110 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", kind: "op", formula: "field.pow:31", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_111, operands: STAGE6_FIELD_EXPR_OPERANDS_111 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_112, operands: STAGE6_FIELD_EXPR_OPERANDS_112 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", kind: "op", formula: "field.pow:32", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_113, operands: STAGE6_FIELD_EXPR_OPERANDS_113 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_114, operands: STAGE6_FIELD_EXPR_OPERANDS_114 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", kind: "op", formula: "field.pow:33", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_115, operands: STAGE6_FIELD_EXPR_OPERANDS_115 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_116, operands: STAGE6_FIELD_EXPR_OPERANDS_116 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", kind: "op", formula: "field.pow:34", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_117, operands: STAGE6_FIELD_EXPR_OPERANDS_117 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_118, operands: STAGE6_FIELD_EXPR_OPERANDS_118 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", kind: "op", formula: "field.pow:35", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_119, operands: STAGE6_FIELD_EXPR_OPERANDS_119 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_120, operands: STAGE6_FIELD_EXPR_OPERANDS_120 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", kind: "op", formula: "field.pow:36", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_121, operands: STAGE6_FIELD_EXPR_OPERANDS_121 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_122, operands: STAGE6_FIELD_EXPR_OPERANDS_122 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", kind: "op", formula: "field.pow:37", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_123, operands: STAGE6_FIELD_EXPR_OPERANDS_123 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_124, operands: STAGE6_FIELD_EXPR_OPERANDS_124 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", kind: "op", formula: "field.pow:38", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_125, operands: STAGE6_FIELD_EXPR_OPERANDS_125 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_126, operands: STAGE6_FIELD_EXPR_OPERANDS_126 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", kind: "op", formula: "field.pow:39", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_127, operands: STAGE6_FIELD_EXPR_OPERANDS_127 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_128, operands: STAGE6_FIELD_EXPR_OPERANDS_128 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", kind: "op", formula: "field.pow:40", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_129, operands: STAGE6_FIELD_EXPR_OPERANDS_129 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_130, operands: STAGE6_FIELD_EXPR_OPERANDS_130 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", kind: "op", formula: "field.pow:41", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_131, operands: STAGE6_FIELD_EXPR_OPERANDS_131 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_132, operands: STAGE6_FIELD_EXPR_OPERANDS_132 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", kind: "op", formula: "field.pow:42", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_133, operands: STAGE6_FIELD_EXPR_OPERANDS_133 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_134, operands: STAGE6_FIELD_EXPR_OPERANDS_134 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term75.gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term75.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_135, operands: STAGE6_FIELD_EXPR_OPERANDS_135 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term76.gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term76.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_136, operands: STAGE6_FIELD_EXPR_OPERANDS_136 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.entry_constant", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_137, operands: STAGE6_FIELD_EXPR_OPERANDS_137 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_138, operands: STAGE6_FIELD_EXPR_OPERANDS_138 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_139, operands: STAGE6_FIELD_EXPR_OPERANDS_139 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial3", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_140, operands: STAGE6_FIELD_EXPR_OPERANDS_140 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial4", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_141, operands: STAGE6_FIELD_EXPR_OPERANDS_141 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial5", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_142, operands: STAGE6_FIELD_EXPR_OPERANDS_142 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial6", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_143, operands: STAGE6_FIELD_EXPR_OPERANDS_143 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial7", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_144, operands: STAGE6_FIELD_EXPR_OPERANDS_144 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial8", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_145, operands: STAGE6_FIELD_EXPR_OPERANDS_145 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial9", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_146, operands: STAGE6_FIELD_EXPR_OPERANDS_146 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial10", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_147, operands: STAGE6_FIELD_EXPR_OPERANDS_147 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial11", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_148, operands: STAGE6_FIELD_EXPR_OPERANDS_148 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial12", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_149, operands: STAGE6_FIELD_EXPR_OPERANDS_149 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial13", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_150, operands: STAGE6_FIELD_EXPR_OPERANDS_150 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial14", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_151, operands: STAGE6_FIELD_EXPR_OPERANDS_151 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial15", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_152, operands: STAGE6_FIELD_EXPR_OPERANDS_152 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial16", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_153, operands: STAGE6_FIELD_EXPR_OPERANDS_153 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial17", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_154, operands: STAGE6_FIELD_EXPR_OPERANDS_154 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial18", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_155, operands: STAGE6_FIELD_EXPR_OPERANDS_155 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial19", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_156, operands: STAGE6_FIELD_EXPR_OPERANDS_156 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial20", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_157, operands: STAGE6_FIELD_EXPR_OPERANDS_157 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial21", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_158, operands: STAGE6_FIELD_EXPR_OPERANDS_158 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial22", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_159, operands: STAGE6_FIELD_EXPR_OPERANDS_159 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial23", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_160, operands: STAGE6_FIELD_EXPR_OPERANDS_160 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial24", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_161, operands: STAGE6_FIELD_EXPR_OPERANDS_161 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial25", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_162, operands: STAGE6_FIELD_EXPR_OPERANDS_162 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial26", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_163, operands: STAGE6_FIELD_EXPR_OPERANDS_163 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial27", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_164, operands: STAGE6_FIELD_EXPR_OPERANDS_164 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial28", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_165, operands: STAGE6_FIELD_EXPR_OPERANDS_165 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial29", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_166, operands: STAGE6_FIELD_EXPR_OPERANDS_166 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial30", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_167, operands: STAGE6_FIELD_EXPR_OPERANDS_167 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial31", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_168, operands: STAGE6_FIELD_EXPR_OPERANDS_168 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial32", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_169, operands: STAGE6_FIELD_EXPR_OPERANDS_169 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial33", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_170, operands: STAGE6_FIELD_EXPR_OPERANDS_170 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial34", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_171, operands: STAGE6_FIELD_EXPR_OPERANDS_171 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial35", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_172, operands: STAGE6_FIELD_EXPR_OPERANDS_172 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial36", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_173, operands: STAGE6_FIELD_EXPR_OPERANDS_173 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial37", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_174, operands: STAGE6_FIELD_EXPR_OPERANDS_174 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial38", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_175, operands: STAGE6_FIELD_EXPR_OPERANDS_175 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial39", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_176, operands: STAGE6_FIELD_EXPR_OPERANDS_176 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial40", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_177, operands: STAGE6_FIELD_EXPR_OPERANDS_177 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial41", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_178, operands: STAGE6_FIELD_EXPR_OPERANDS_178 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial42", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_179, operands: STAGE6_FIELD_EXPR_OPERANDS_179 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial43", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_180, operands: STAGE6_FIELD_EXPR_OPERANDS_180 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial44", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_181, operands: STAGE6_FIELD_EXPR_OPERANDS_181 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial45", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_182, operands: STAGE6_FIELD_EXPR_OPERANDS_182 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial46", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_183, operands: STAGE6_FIELD_EXPR_OPERANDS_183 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial47", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_184, operands: STAGE6_FIELD_EXPR_OPERANDS_184 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial48", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_185, operands: STAGE6_FIELD_EXPR_OPERANDS_185 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial49", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_186, operands: STAGE6_FIELD_EXPR_OPERANDS_186 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial50", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_187, operands: STAGE6_FIELD_EXPR_OPERANDS_187 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial51", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_188, operands: STAGE6_FIELD_EXPR_OPERANDS_188 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial52", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_189, operands: STAGE6_FIELD_EXPR_OPERANDS_189 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial53", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_190, operands: STAGE6_FIELD_EXPR_OPERANDS_190 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial54", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_191, operands: STAGE6_FIELD_EXPR_OPERANDS_191 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial55", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_192, operands: STAGE6_FIELD_EXPR_OPERANDS_192 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial56", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_193, operands: STAGE6_FIELD_EXPR_OPERANDS_193 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial57", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_194, operands: STAGE6_FIELD_EXPR_OPERANDS_194 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial58", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_195, operands: STAGE6_FIELD_EXPR_OPERANDS_195 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial59", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_196, operands: STAGE6_FIELD_EXPR_OPERANDS_196 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial60", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_197, operands: STAGE6_FIELD_EXPR_OPERANDS_197 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial61", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_198, operands: STAGE6_FIELD_EXPR_OPERANDS_198 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial62", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_199, operands: STAGE6_FIELD_EXPR_OPERANDS_199 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial63", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_200, operands: STAGE6_FIELD_EXPR_OPERANDS_200 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial64", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_201, operands: STAGE6_FIELD_EXPR_OPERANDS_201 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial65", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_202, operands: STAGE6_FIELD_EXPR_OPERANDS_202 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial66", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_203, operands: STAGE6_FIELD_EXPR_OPERANDS_203 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial67", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_204, operands: STAGE6_FIELD_EXPR_OPERANDS_204 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial68", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_205, operands: STAGE6_FIELD_EXPR_OPERANDS_205 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial69", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_206, operands: STAGE6_FIELD_EXPR_OPERANDS_206 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial70", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_207, operands: STAGE6_FIELD_EXPR_OPERANDS_207 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial71", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_208, operands: STAGE6_FIELD_EXPR_OPERANDS_208 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial72", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_209, operands: STAGE6_FIELD_EXPR_OPERANDS_209 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial73", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_210, operands: STAGE6_FIELD_EXPR_OPERANDS_210 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial74", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_211, operands: STAGE6_FIELD_EXPR_OPERANDS_211 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial75", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_212, operands: STAGE6_FIELD_EXPR_OPERANDS_212 },
+    Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial76", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_213, operands: STAGE6_FIELD_EXPR_OPERANDS_213 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term1.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term1.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term2.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term2.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_216, operands: STAGE6_FIELD_EXPR_OPERANDS_216 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term3.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term3.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_217, operands: STAGE6_FIELD_EXPR_OPERANDS_217 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term4.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_218, operands: STAGE6_FIELD_EXPR_OPERANDS_218 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term5.gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term5.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_219, operands: STAGE6_FIELD_EXPR_OPERANDS_219 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term6.gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term6.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_220, operands: STAGE6_FIELD_EXPR_OPERANDS_220 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term7.gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term7.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_221, operands: STAGE6_FIELD_EXPR_OPERANDS_221 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_222, operands: STAGE6_FIELD_EXPR_OPERANDS_222 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_223, operands: STAGE6_FIELD_EXPR_OPERANDS_223 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_224, operands: STAGE6_FIELD_EXPR_OPERANDS_224 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial3", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_225, operands: STAGE6_FIELD_EXPR_OPERANDS_225 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial4", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_226, operands: STAGE6_FIELD_EXPR_OPERANDS_226 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial5", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_227, operands: STAGE6_FIELD_EXPR_OPERANDS_227 },
+    Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial6", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_228, operands: STAGE6_FIELD_EXPR_OPERANDS_228 },
+    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_229, operands: STAGE6_FIELD_EXPR_OPERANDS_229 },
+    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_230, operands: STAGE6_FIELD_EXPR_OPERANDS_230 },
+    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_229, operands: STAGE6_FIELD_EXPR_OPERANDS_229 },
+    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_231, operands: STAGE6_FIELD_EXPR_OPERANDS_231 },
+    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_229, operands: STAGE6_FIELD_EXPR_OPERANDS_229 },
+    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_232, operands: STAGE6_FIELD_EXPR_OPERANDS_232 },
+    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_233, operands: STAGE6_FIELD_EXPR_OPERANDS_233 },
+    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_234, operands: STAGE6_FIELD_EXPR_OPERANDS_234 },
+    Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_235, operands: STAGE6_FIELD_EXPR_OPERANDS_235 },
 ];
 pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[
     Stage6KernelPlan { symbol: "jolt.cpu.stage6.bytecode_read_raf", relation: "jolt.stage6.bytecode_read_raf", kind: "sumcheck", backend: "cpu", abi: "jolt_stage6_bytecode_read_raf" },
@@ -1886,18 +1802,12 @@ pub const STAGE6_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[
     "stage6.inc_claim_reduction.input",
 ];
 
-pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    10,
-    16,
-];
+pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[10, 16];
 
 pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[
     Stage6SumcheckBatchPlan { symbol: "stage6.batch", stage: "stage6", proof_slot: "stage6.sumcheck", policy: "jolt_core_stage6_aligned", count: 6, ordered_claims: STAGE6_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE6_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
-pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    10,
-    16,
-];
+pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[10, 16];
 
 pub const STAGE6_SUMCHECK_DRIVERS: &[Stage6SumcheckDriverPlan] = &[
     Stage6SumcheckDriverPlan { symbol: "stage6.sumcheck", stage: "stage6", proof_slot: "stage6.sumcheck", kernel: Some("jolt.cpu.stage6.batched"), relation: None, batch: "stage6.batch", policy: "jolt_core_stage6_aligned", round_schedule: STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 26, degree: 5 },
@@ -1911,35 +1821,33 @@ pub const STAGE6_SUMCHECK_INSTANCE_RESULTS: &[Stage6SumcheckInstanceResultPlan]
     Stage6SumcheckInstanceResultPlan { symbol: "stage6.inc_claim_reduction.instance", source: "stage6.sumcheck", claim: "stage6.inc_claim_reduction.input", relation: "jolt.stage6.inc_claim_reduction", index: 5, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 2 },
 ];
 
-macro_rules! stage6_sumcheck_eval {
-    ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => {
-        Stage6SumcheckEvalPlan { symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle }
-    };
+const fn stage6_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage6SumcheckEvalPlan {
+    Stage6SumcheckEvalPlan { symbol, source, name, index, oracle }
 }
 
 #[rustfmt::skip]
 pub const STAGE6_SUMCHECK_EVALS: &[Stage6SumcheckEvalPlan] = &[
-    stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_0", 0, "BytecodeRa_0"), stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_1", 1, "BytecodeRa_1"), stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_2", 2, "BytecodeRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_0", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_0", 0, "InstructionRa_0"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_1", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_2", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_3", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_4", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_4", 4, "InstructionRa_4"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_5", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_6", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_7", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_8", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_8", 8, "InstructionRa_8"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_9", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_10", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_11", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_12", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_12", 12, "InstructionRa_12"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_13", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_14", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_15", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_16", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_16", 16, "InstructionRa_16"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_17", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_18", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_19", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_20", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_20", 20, "InstructionRa_20"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_21", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_22", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_23", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_24", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_24", 24, "InstructionRa_24"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_25", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_26", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_27", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_28", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_28", 28, "InstructionRa_28"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_29", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_30", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_31", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_0", 32, "BytecodeRa_0"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_0", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_0", 35, "RamRa_0"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_1", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_1", 36, "RamRa_1"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_2", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_2", 37, "RamRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_3", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_3", 38, "RamRa_3"), stage6_sumcheck_eval!("stage6.hamming_booleanity.eval.HammingWeight", "stage6.sumcheck", "stage6.hamming_booleanity.eval.HammingWeight", 0, "HammingWeight"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_0", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_0", 0, "RamRa_0"),
-    stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_1", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_1", 1, "RamRa_1"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_2", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_2", 2, "RamRa_2"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_3", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_3", 3, "RamRa_3"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_0", 0, "InstructionRa_0"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_4", 4, "InstructionRa_4"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_8", 8, "InstructionRa_8"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_12", 12, "InstructionRa_12"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_16", 16, "InstructionRa_16"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_20", 20, "InstructionRa_20"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_24", 24, "InstructionRa_24"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_28", 28, "InstructionRa_28"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval!("stage6.inc_claim_reduction.eval.RamInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RamInc", 0, "RamInc"),
-    stage6_sumcheck_eval!("stage6.inc_claim_reduction.eval.RdInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RdInc", 1, "RdInc"),
+    stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_0", 0, "BytecodeRa_0"), stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_1", 1, "BytecodeRa_1"), stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_2", 2, "BytecodeRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_0", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_0", 0, "InstructionRa_0"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_1", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_2", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_3", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_4", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_4", 4, "InstructionRa_4"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_5", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_6", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_7", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_8", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_8", 8, "InstructionRa_8"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_9", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_10", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_11", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_12", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_12", 12, "InstructionRa_12"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_13", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_14", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_15", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_16", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_16", 16, "InstructionRa_16"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_17", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_18", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_19", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_20", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_20", 20, "InstructionRa_20"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_21", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_22", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_23", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_24", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_24", 24, "InstructionRa_24"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_25", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_26", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_27", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_28", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_28", 28, "InstructionRa_28"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_29", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_30", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_31", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_0", 32, "BytecodeRa_0"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_0", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_0", 35, "RamRa_0"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_1", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_1", 36, "RamRa_1"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_2", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_2", 37, "RamRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_3", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_3", 38, "RamRa_3"), stage6_sumcheck_eval("stage6.hamming_booleanity.eval.HammingWeight", "stage6.sumcheck", "stage6.hamming_booleanity.eval.HammingWeight", 0, "HammingWeight"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_0", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_0", 0, "RamRa_0"),
+    stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_1", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_1", 1, "RamRa_1"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_2", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_2", 2, "RamRa_2"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_3", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_3", 3, "RamRa_3"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_0", 0, "InstructionRa_0"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_4", 4, "InstructionRa_4"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_8", 8, "InstructionRa_8"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_12", 12, "InstructionRa_12"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_16", 16, "InstructionRa_16"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_20", 20, "InstructionRa_20"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_24", 24, "InstructionRa_24"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_28", 28, "InstructionRa_28"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval("stage6.inc_claim_reduction.eval.RamInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RamInc", 0, "RamInc"),
+    stage6_sumcheck_eval("stage6.inc_claim_reduction.eval.RdInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RdInc", 1, "RdInc"),
 ];
 
 pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[
@@ -1987,6 +1895,8 @@ pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[
     Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" },
     Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" },
     Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" },
+    Stage6PointSlicePlan { symbol: "stage6.booleanity.output.point.Address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" },
+    Stage6PointSlicePlan { symbol: "stage6.booleanity.output.point.Cycle", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 16, length: 16, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" },
 ];
 
 pub const STAGE6_POINT_CONCAT_0_INPUTS: &[&str] = &[
@@ -2189,6 +2099,11 @@ pub const STAGE6_POINT_CONCAT_39_INPUTS: &[&str] = &[
     "stage6.instruction_ra_virtual.instance",
 ];
 
+pub const STAGE6_POINT_CONCAT_40_INPUTS: &[&str] = &[
+    "stage6.booleanity.output.point.Address",
+    "stage6.booleanity.output.point.Cycle",
+];
+
 pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[
     Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address", layout: "left_zero_padded_address_chunk", arity: 4, inputs: STAGE6_POINT_CONCAT_0_INPUTS },
     Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_1_INPUTS },
@@ -2230,6 +2145,7 @@ pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[
     Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29", layout: "address_chunk_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_37_INPUTS },
     Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30", layout: "address_chunk_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_38_INPUTS },
     Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", layout: "address_chunk_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_39_INPUTS },
+    Stage6PointConcatPlan { symbol: "stage6.booleanity.output.point", layout: "address_prefix_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_40_INPUTS },
 ];
 pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[
     Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.bytecode_read_raf.point.BytecodeRa_0", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_0" },
diff --git a/crates/jolt-prover/src/stages/stage7.rs b/crates/jolt-prover/src/stages/stage7.rs
index 831534a4b9..5f497a8d85 100644
--- a/crates/jolt-prover/src/stages/stage7.rs
+++ b/crates/jolt-prover/src/stages/stage7.rs
@@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript};
 
 pub type DefaultStage7Transcript = Blake2bTranscript<Fr>;
 
-pub const STAGE7_PARAMS: Stage7Params = Stage7Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE7_PARAMS: Stage7Params = Stage7Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE7_PROGRAM_STEPS: &[Stage7ProgramStepPlan] = &[
     Stage7ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage7.hamming_weight_claim_reduction.gamma" },
     Stage7ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage7.sumcheck" },
@@ -1716,16 +1712,12 @@ pub const STAGE7_SUMCHECK_BATCH_0_ORDERED_CLAIMS: &[&str] = &["stage7.hamming_we
 
 pub const STAGE7_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &["stage7.hamming_weight_claim_reduction.input"];
 
-pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    4,
-];
+pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[4];
 
 pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[
     Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, ordered_claims: STAGE7_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE7_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
-pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    4,
-];
+pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4];
 
 pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[
     Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: Some("jolt.cpu.stage7.batched"), relation: None, batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 },
@@ -1734,24 +1726,22 @@ pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan]
     Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: "jolt.stage7.hamming_weight_claim_reduction", index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: "reverse", degree: 2 },
 ];
 
-macro_rules! stage7_sumcheck_eval {
-    ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => {
-        Stage7SumcheckEvalPlan { symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle }
-    };
+const fn stage7_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage7SumcheckEvalPlan {
+    Stage7SumcheckEvalPlan { symbol, source, name, index, oracle }
 }
 
 #[rustfmt::skip]
 pub const STAGE7_SUMCHECK_EVALS: &[Stage7SumcheckEvalPlan] = &[
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", 0, "InstructionRa_0"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", 1, "InstructionRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", 2, "InstructionRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", 3, "InstructionRa_3"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", 4, "InstructionRa_4"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", 5, "InstructionRa_5"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", 6, "InstructionRa_6"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", 7, "InstructionRa_7"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", 8, "InstructionRa_8"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", 9, "InstructionRa_9"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", 10, "InstructionRa_10"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", 11, "InstructionRa_11"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", 12, "InstructionRa_12"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", 13, "InstructionRa_13"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", 14, "InstructionRa_14"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", 15, "InstructionRa_15"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", 16, "InstructionRa_16"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", 17, "InstructionRa_17"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", 18, "InstructionRa_18"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", 19, "InstructionRa_19"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", 20, "InstructionRa_20"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", 21, "InstructionRa_21"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", 22, "InstructionRa_22"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", 23, "InstructionRa_23"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", 24, "InstructionRa_24"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", 25, "InstructionRa_25"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", 26, "InstructionRa_26"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", 27, "InstructionRa_27"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", 28, "InstructionRa_28"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", 29, "InstructionRa_29"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", 30, "InstructionRa_30"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", 31, "InstructionRa_31"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", 32, "BytecodeRa_0"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", 35, "RamRa_0"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", 36, "RamRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", 37, "RamRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", 38, "RamRa_3"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", 0, "InstructionRa_0"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", 1, "InstructionRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", 2, "InstructionRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", 3, "InstructionRa_3"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", 4, "InstructionRa_4"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", 5, "InstructionRa_5"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", 6, "InstructionRa_6"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", 7, "InstructionRa_7"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", 8, "InstructionRa_8"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", 9, "InstructionRa_9"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", 10, "InstructionRa_10"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", 11, "InstructionRa_11"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", 12, "InstructionRa_12"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", 13, "InstructionRa_13"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", 14, "InstructionRa_14"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", 15, "InstructionRa_15"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", 16, "InstructionRa_16"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", 17, "InstructionRa_17"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", 18, "InstructionRa_18"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", 19, "InstructionRa_19"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", 20, "InstructionRa_20"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", 21, "InstructionRa_21"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", 22, "InstructionRa_22"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", 23, "InstructionRa_23"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", 24, "InstructionRa_24"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", 25, "InstructionRa_25"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", 26, "InstructionRa_26"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", 27, "InstructionRa_27"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", 28, "InstructionRa_28"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", 29, "InstructionRa_29"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", 30, "InstructionRa_30"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", 31, "InstructionRa_31"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", 32, "BytecodeRa_0"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", 35, "RamRa_0"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", 36, "RamRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", 37, "RamRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", 38, "RamRa_3"),
 ];
 
 pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[
diff --git a/crates/jolt-prover/src/stages/stage8.rs b/crates/jolt-prover/src/stages/stage8.rs
index 632dbe3925..1ad54c149a 100644
--- a/crates/jolt-prover/src/stages/stage8.rs
+++ b/crates/jolt-prover/src/stages/stage8.rs
@@ -7,47 +7,126 @@ pub struct Stage8Params {
     pub transcript: &'static str,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage8ClaimKind {
+    Committed,
+    Virtual,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage8SourceStage {
+    Stage6,
+    Stage7,
+}
+
+impl Stage8SourceStage {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Stage6 => "stage6",
+            Self::Stage7 => "stage7",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Stage8OpeningInputSymbol(&'static str);
+
+impl Stage8OpeningInputSymbol {
+    pub const fn new(symbol: &'static str) -> Self {
+        Self(symbol)
+    }
+
+    pub fn as_str(self) -> &'static str {
+        self.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Stage8OpeningClaimSymbol(&'static str);
+
+impl Stage8OpeningClaimSymbol {
+    pub const fn new(symbol: &'static str) -> Self {
+        Self(symbol)
+    }
+
+    pub fn as_str(self) -> &'static str {
+        self.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Stage8OpeningBatchSymbol(&'static str);
+
+impl Stage8OpeningBatchSymbol {
+    pub const fn new(symbol: &'static str) -> Self {
+        Self(symbol)
+    }
+
+    pub fn as_str(self) -> &'static str {
+        self.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Stage8SourceClaim(&'static str);
+
+impl Stage8SourceClaim {
+    pub const fn new(symbol: &'static str) -> Self {
+        Self(symbol)
+    }
+
+    pub fn as_str(self) -> &'static str {
+        self.0
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Stage8OpeningInputPlan {
-    pub symbol: &'static str,
-    pub source_stage: &'static str,
-    pub source_claim: &'static str,
+    pub symbol: Stage8OpeningInputSymbol,
+    pub source_stage: Stage8SourceStage,
+    pub source_claim: Stage8SourceClaim,
     pub oracle: &'static str,
     pub domain: &'static str,
     pub point_arity: usize,
-    pub claim_kind: &'static str,
+    pub claim_kind: Stage8ClaimKind,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Stage8OpeningClaimPlan {
-    pub symbol: &'static str,
+    pub symbol: Stage8OpeningClaimSymbol,
     pub oracle: &'static str,
     pub family: &'static str,
     pub domain: &'static str,
     pub point_arity: usize,
-    pub point_source: &'static str,
-    pub eval_source: &'static str,
-    pub source_stage: &'static str,
-    pub source_claim: &'static str,
+    pub point_source: Stage8OpeningInputSymbol,
+    pub eval_source: Stage8OpeningInputSymbol,
+    pub source_stage: Stage8SourceStage,
+    pub source_claim: Stage8SourceClaim,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Stage8OpeningBatchPlan {
-    pub symbol: &'static str,
+    pub symbol: Stage8OpeningBatchSymbol,
     pub proof_slot: &'static str,
     pub policy: &'static str,
     pub count: usize,
-    pub ordered_claims: &'static [&'static str],
+    pub ordered_claims: &'static [Stage8OpeningClaimPlan],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage8PcsProofMode {
+    Open,
+    Verify,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Stage8PcsProofPlan {
     pub symbol: &'static str,
-    pub mode: &'static str,
+    pub mode: Stage8PcsProofMode,
     pub pcs: &'static str,
     pub proof_slot: &'static str,
     pub transcript_label: &'static str,
-    pub batch: &'static str,
+    pub batch: Stage8OpeningBatchSymbol,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -62,112 +141,336 @@ pub struct Stage8EvaluationProgramPlan {
     pub pcs_proof: Stage8PcsProofPlan,
 }
 
+const fn stage8_opening_input(
+    symbol: &'static str,
+    source_stage: Stage8SourceStage,
+    source_claim: &'static str,
+    oracle: &'static str,
+    domain: &'static str,
+    point_arity: usize,
+    claim_kind: Stage8ClaimKind,
+) -> Stage8OpeningInputPlan {
+    Stage8OpeningInputPlan {
+        symbol: Stage8OpeningInputSymbol::new(symbol),
+        source_stage,
+        source_claim: Stage8SourceClaim::new(source_claim),
+        oracle,
+        domain,
+        point_arity,
+        claim_kind,
+    }
+}
+
+const fn stage8_opening_claim(
+    symbol: &'static str,
+    oracle: &'static str,
+    family: &'static str,
+    domain: &'static str,
+    point_arity: usize,
+    input_symbol: &'static str,
+    source: (Stage8SourceStage, &'static str),
+) -> Stage8OpeningClaimPlan {
+    Stage8OpeningClaimPlan {
+        symbol: Stage8OpeningClaimSymbol::new(symbol),
+        oracle,
+        family,
+        domain,
+        point_arity,
+        point_source: Stage8OpeningInputSymbol::new(input_symbol),
+        eval_source: Stage8OpeningInputSymbol::new(input_symbol),
+        source_stage: source.0,
+        source_claim: Stage8SourceClaim::new(source.1),
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage8EvaluationClaim<F> {
+    pub oracle: &'static str,
+    pub source_stage: Stage8SourceStage,
+    pub value: F,
+}
+
+pub fn reverse_point<F: Copy>(point: &[F]) -> Vec<F> {
+    point.iter().rev().copied().collect()
+}
+
+pub fn append_rlc_claims<F, T>(transcript: &mut T, claims: &[Stage8EvaluationClaim<F>])
+where
+    F: jolt_field::Field + jolt_transcript::AppendToTranscript,
+    T: jolt_transcript::Transcript<Challenge = F>,
+{
+    transcript.append(&jolt_transcript::LabelWithCount(
+        b"rlc_claims",
+        claims.len() as u64,
+    ));
+    for claim in claims {
+        jolt_transcript::AppendToTranscript::append_to_transcript(&claim.value, transcript);
+    }
+}
+
+pub fn gamma_powers<F, T>(transcript: &mut T, count: usize) -> Vec<F>
+where
+    F: jolt_field::Field,
+    T: jolt_transcript::Transcript<Challenge = F>,
+{
+    let gamma = transcript.challenge();
+    let mut powers = Vec::with_capacity(count);
+    let mut power = F::from_u64(1);
+    for _ in 0..count {
+        powers.push(power);
+        power *= gamma;
+    }
+    powers
+}
+
+pub trait Stage8NamedEvalView<F> {
+    fn name(&self) -> &'static str;
+    fn value(&self) -> F;
+}
+
+pub trait Stage8SumcheckOutputView<F> {
+    type Eval: Stage8NamedEvalView<F>;
+
+    fn point(&self) -> &[F];
+    fn evals(&self) -> &[Self::Eval];
+}
+
+pub fn stage7_claim_values<F, O>(
+    program: &'static Stage8EvaluationProgramPlan,
+    outputs: &[O],
+) -> Option<(Vec<F>, std::collections::BTreeMap<Stage8SourceClaim, F>)>
+where
+    F: Copy,
+    O: Stage8SumcheckOutputView<F>,
+{
+    let stage7_plans = program
+        .opening_claims
+        .iter()
+        .filter(|plan| plan.source_stage == Stage8SourceStage::Stage7)
+        .collect::<Vec<_>>();
+    for output in outputs {
+        let mut values = std::collections::BTreeMap::new();
+        for plan in &stage7_plans {
+            if let Some(eval) = output
+                .evals()
+                .iter()
+                .find(|eval| eval.name() == plan.source_claim.as_str())
+            {
+                let _ = values.insert(plan.source_claim, eval.value());
+            }
+        }
+        if values.len() == stage7_plans.len() {
+            return Some((output.point().to_vec(), values));
+        }
+    }
+    None
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage8EvaluationClaimError {
+    pub stage: &'static str,
+    pub eval: &'static str,
+}
+
+pub fn evaluation_claims<F, O>(
+    program: &'static Stage8EvaluationProgramPlan,
+    stage6_outputs: &[O],
+    stage7_values: &std::collections::BTreeMap<Stage8SourceClaim, F>,
+    lagrange_factor: F,
+) -> Result<Vec<Stage8EvaluationClaim<F>>, Stage8EvaluationClaimError>
+where
+    F: Copy + std::ops::Mul<Output = F>,
+    O: Stage8SumcheckOutputView<F>,
+{
+    let mut claims = Vec::with_capacity(program.opening_claims.len());
+    for plan in program.opening_claims {
+        let value = match plan.source_stage {
+            Stage8SourceStage::Stage6 => {
+                stage_eval(stage6_outputs, plan.source_stage.as_str(), plan.source_claim)?
+                    * lagrange_factor
+            }
+            Stage8SourceStage::Stage7 => *stage7_values.get(&plan.source_claim).ok_or(
+                Stage8EvaluationClaimError {
+                    stage: plan.source_stage.as_str(),
+                    eval: plan.source_claim.as_str(),
+                },
+            )?,
+        };
+        claims.push(Stage8EvaluationClaim {
+            oracle: plan.oracle,
+            source_stage: plan.source_stage,
+            value,
+        });
+    }
+    Ok(claims)
+}
+
+fn stage_eval<F, O>(
+    outputs: &[O],
+    stage: &'static str,
+    eval_name: Stage8SourceClaim,
+) -> Result<F, Stage8EvaluationClaimError>
+where
+    F: Copy,
+    O: Stage8SumcheckOutputView<F>,
+{
+    for output in outputs {
+        let eval = output
+            .evals()
+            .iter()
+            .find(|eval| eval.name() == eval_name.as_str());
+        if let Some(eval) = eval { return Ok(eval.value()); }
+    }
+    Err(Stage8EvaluationClaimError {
+        stage,
+        eval: eval_name.as_str(),
+    })
+}
+
+pub trait Stage8OpeningInputView<F> {
+    fn symbol(&self) -> &'static str;
+    fn point(&self) -> &[F];
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage8EvaluationOpeningPointError {
+    MissingStage7EvaluationPoint,
+    InvalidPointLength {
+        artifact: &'static str,
+        expected: usize,
+        actual: usize,
+    },
+}
+
+pub fn stage7_evaluation_opening_point<F, I>(
+    program: &'static Stage8EvaluationProgramPlan,
+    address_point: &[F],
+    stage7_openings: &[I],
+) -> Result<(Vec<F>, usize), Stage8EvaluationOpeningPointError>
+where
+    F: Copy,
+    I: Stage8OpeningInputView<F>,
+{
+    let cycle_source_symbol = program.evaluation_point_source.source_claim;
+    let cycle_source = stage7_openings
+        .iter()
+        .find(|input| input.symbol() == cycle_source_symbol.as_str())
+        .ok_or(Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint)?;
+    let cycle_source_point = cycle_source.point();
+    if cycle_source_point.len() < address_point.len() {
+        return Err(Stage8EvaluationOpeningPointError::InvalidPointLength {
+            artifact: cycle_source_symbol.as_str(),
+            expected: address_point.len(),
+            actual: cycle_source_point.len(),
+        });
+    }
+    let cycle_len = cycle_source_point.len() - address_point.len();
+    let mut point = Vec::with_capacity(cycle_source_point.len());
+    point.extend_from_slice(address_point);
+    point.extend_from_slice(&cycle_source_point[address_point.len()..]);
+    Ok((point, cycle_len))
+}
+
 pub const STAGE8_PARAMS: Stage8Params = Stage8Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 
-pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = Stage8OpeningInputPlan { symbol: "stage8.evaluation.point_source", source_stage: "stage7", source_claim: "stage7.input.stage6.booleanity.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" };
+pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = stage8_opening_input("stage8.evaluation.point_source", Stage8SourceStage::Stage7, "stage7.input.stage6.booleanity.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed);
 
+#[rustfmt::skip]
 pub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[
-    Stage8OpeningInputPlan { symbol: "stage8.evaluation.point_source", source_stage: "stage7", source_claim: "stage7.input.stage6.booleanity.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage6.RamInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RamInc", oracle: "RamInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage6.RdInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RdInc", oracle: "RdInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_4", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_5", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_6", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_7", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_8", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_9", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_10", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_11", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_12", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_13", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_14", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_15", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_16", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_17", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_18", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_19", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_20", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_21", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_22", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_23", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_24", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_25", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_26", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_27", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_28", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_29", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_30", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_31", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
+    stage8_opening_input("stage8.evaluation.point_source", Stage8SourceStage::Stage7, "stage7.input.stage6.booleanity.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage6.RamInc", Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RamInc", "RamInc", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage6.RdInc", Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RdInc", "RdInc", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "InstructionRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "InstructionRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_3", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "InstructionRa_3", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_4", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "InstructionRa_4", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_5", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "InstructionRa_5", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_6", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "InstructionRa_6", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_7", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "InstructionRa_7", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_8", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "InstructionRa_8", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_9", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "InstructionRa_9", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_10", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "InstructionRa_10", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_11", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "InstructionRa_11", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_12", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "InstructionRa_12", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_13", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "InstructionRa_13", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_14", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "InstructionRa_14", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_15", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "InstructionRa_15", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_16", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "InstructionRa_16", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_17", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "InstructionRa_17", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_18", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "InstructionRa_18", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_19", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "InstructionRa_19", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_20", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "InstructionRa_20", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_21", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "InstructionRa_21", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_22", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "InstructionRa_22", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_23", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "InstructionRa_23", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_24", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "InstructionRa_24", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_25", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "InstructionRa_25", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_26", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "InstructionRa_26", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_27", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "InstructionRa_27", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_28", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "InstructionRa_28", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_29", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "InstructionRa_29", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_30", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "InstructionRa_30", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_31", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "InstructionRa_31", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.BytecodeRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "BytecodeRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.BytecodeRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "BytecodeRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.BytecodeRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "BytecodeRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.RamRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "RamRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.RamRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "RamRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.RamRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "RamRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.RamRa_3", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "RamRa_3", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
 ];
 
+#[rustfmt::skip]
 pub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamInc", oracle: "RamInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage6.RamInc", eval_source: "stage8.input.stage6.RamInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RamInc" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RdInc", oracle: "RdInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage6.RdInc", eval_source: "stage8.input.stage6.RdInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RdInc" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_0", oracle: "InstructionRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_0", eval_source: "stage8.input.stage7.InstructionRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_1", oracle: "InstructionRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_1", eval_source: "stage8.input.stage7.InstructionRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_2", oracle: "InstructionRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_2", eval_source: "stage8.input.stage7.InstructionRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_3", oracle: "InstructionRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_3", eval_source: "stage8.input.stage7.InstructionRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_4", oracle: "InstructionRa_4", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_4", eval_source: "stage8.input.stage7.InstructionRa_4", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_5", oracle: "InstructionRa_5", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_5", eval_source: "stage8.input.stage7.InstructionRa_5", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_6", oracle: "InstructionRa_6", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_6", eval_source: "stage8.input.stage7.InstructionRa_6", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_7", oracle: "InstructionRa_7", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_7", eval_source: "stage8.input.stage7.InstructionRa_7", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_8", oracle: "InstructionRa_8", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_8", eval_source: "stage8.input.stage7.InstructionRa_8", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_9", oracle: "InstructionRa_9", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_9", eval_source: "stage8.input.stage7.InstructionRa_9", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_10", oracle: "InstructionRa_10", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_10", eval_source: "stage8.input.stage7.InstructionRa_10", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_11", oracle: "InstructionRa_11", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_11", eval_source: "stage8.input.stage7.InstructionRa_11", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_12", oracle: "InstructionRa_12", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_12", eval_source: "stage8.input.stage7.InstructionRa_12", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_13", oracle: "InstructionRa_13", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_13", eval_source: "stage8.input.stage7.InstructionRa_13", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_14", oracle: "InstructionRa_14", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_14", eval_source: "stage8.input.stage7.InstructionRa_14", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_15", oracle: "InstructionRa_15", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_15", eval_source: "stage8.input.stage7.InstructionRa_15", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_16", oracle: "InstructionRa_16", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_16", eval_source: "stage8.input.stage7.InstructionRa_16", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_17", oracle: "InstructionRa_17", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_17", eval_source: "stage8.input.stage7.InstructionRa_17", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_18", oracle: "InstructionRa_18", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_18", eval_source: "stage8.input.stage7.InstructionRa_18", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_19", oracle: "InstructionRa_19", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_19", eval_source: "stage8.input.stage7.InstructionRa_19", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_20", oracle: "InstructionRa_20", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_20", eval_source: "stage8.input.stage7.InstructionRa_20", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_21", oracle: "InstructionRa_21", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_21", eval_source: "stage8.input.stage7.InstructionRa_21", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_22", oracle: "InstructionRa_22", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_22", eval_source: "stage8.input.stage7.InstructionRa_22", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_23", oracle: "InstructionRa_23", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_23", eval_source: "stage8.input.stage7.InstructionRa_23", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_24", oracle: "InstructionRa_24", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_24", eval_source: "stage8.input.stage7.InstructionRa_24", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_25", oracle: "InstructionRa_25", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_25", eval_source: "stage8.input.stage7.InstructionRa_25", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_26", oracle: "InstructionRa_26", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_26", eval_source: "stage8.input.stage7.InstructionRa_26", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_27", oracle: "InstructionRa_27", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_27", eval_source: "stage8.input.stage7.InstructionRa_27", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_28", oracle: "InstructionRa_28", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_28", eval_source: "stage8.input.stage7.InstructionRa_28", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_29", oracle: "InstructionRa_29", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_29", eval_source: "stage8.input.stage7.InstructionRa_29", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_30", oracle: "InstructionRa_30", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_30", eval_source: "stage8.input.stage7.InstructionRa_30", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_31", oracle: "InstructionRa_31", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_31", eval_source: "stage8.input.stage7.InstructionRa_31", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_0", oracle: "BytecodeRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_0", eval_source: "stage8.input.stage7.BytecodeRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_1", oracle: "BytecodeRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_1", eval_source: "stage8.input.stage7.BytecodeRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_2", oracle: "BytecodeRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_2", eval_source: "stage8.input.stage7.BytecodeRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_0", oracle: "RamRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_0", eval_source: "stage8.input.stage7.RamRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_0" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_1", oracle: "RamRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_1", eval_source: "stage8.input.stage7.RamRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_1" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_2", oracle: "RamRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_2", eval_source: "stage8.input.stage7.RamRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_2" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_3", oracle: "RamRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_3", eval_source: "stage8.input.stage7.RamRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_3" },
+    stage8_opening_claim("stage8.evaluation.opening.RamInc", "RamInc", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage6.RamInc", (Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RamInc")),
+    stage8_opening_claim("stage8.evaluation.opening.RdInc", "RdInc", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage6.RdInc", (Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RdInc")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_1", "InstructionRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_2", "InstructionRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_3", "InstructionRa_3", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_3", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_4", "InstructionRa_4", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_4", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_5", "InstructionRa_5", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_5", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_6", "InstructionRa_6", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_6", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_7", "InstructionRa_7", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_7", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_8", "InstructionRa_8", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_8", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_9", "InstructionRa_9", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_9", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_10", "InstructionRa_10", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_10", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_11", "InstructionRa_11", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_11", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_12", "InstructionRa_12", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_12", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_13", "InstructionRa_13", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_13", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_14", "InstructionRa_14", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_14", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_15", "InstructionRa_15", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_15", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_16", "InstructionRa_16", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_16", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_17", "InstructionRa_17", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_17", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_18", "InstructionRa_18", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_18", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_19", "InstructionRa_19", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_19", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_20", "InstructionRa_20", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_20", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_21", "InstructionRa_21", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_21", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_22", "InstructionRa_22", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_22", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_23", "InstructionRa_23", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_23", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_24", "InstructionRa_24", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_24", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_25", "InstructionRa_25", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_25", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_26", "InstructionRa_26", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_26", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_27", "InstructionRa_27", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_27", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_28", "InstructionRa_28", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_28", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_29", "InstructionRa_29", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_29", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_30", "InstructionRa_30", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_30", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_31", "InstructionRa_31", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_31", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31")),
+    stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_0", "BytecodeRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0")),
+    stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_1", "BytecodeRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1")),
+    stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_2", "BytecodeRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2")),
+    stage8_opening_claim("stage8.evaluation.opening.RamRa_0", "RamRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_0")),
+    stage8_opening_claim("stage8.evaluation.opening.RamRa_1", "RamRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_1")),
+    stage8_opening_claim("stage8.evaluation.opening.RamRa_2", "RamRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_2")),
+    stage8_opening_claim("stage8.evaluation.opening.RamRa_3", "RamRa_3", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_3", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_3")),
 ];
 
-pub const STAGE8_OPENING_BATCH_ORDERED_CLAIMS: &[&str] = &["stage8.evaluation.opening.RamInc", "stage8.evaluation.opening.RdInc", "stage8.evaluation.opening.InstructionRa_0", "stage8.evaluation.opening.InstructionRa_1", "stage8.evaluation.opening.InstructionRa_2", "stage8.evaluation.opening.InstructionRa_3", "stage8.evaluation.opening.InstructionRa_4", "stage8.evaluation.opening.InstructionRa_5", "stage8.evaluation.opening.InstructionRa_6", "stage8.evaluation.opening.InstructionRa_7", "stage8.evaluation.opening.InstructionRa_8", "stage8.evaluation.opening.InstructionRa_9", "stage8.evaluation.opening.InstructionRa_10", "stage8.evaluation.opening.InstructionRa_11", "stage8.evaluation.opening.InstructionRa_12", "stage8.evaluation.opening.InstructionRa_13", "stage8.evaluation.opening.InstructionRa_14", "stage8.evaluation.opening.InstructionRa_15", "stage8.evaluation.opening.InstructionRa_16", "stage8.evaluation.opening.InstructionRa_17", "stage8.evaluation.opening.InstructionRa_18", "stage8.evaluation.opening.InstructionRa_19", "stage8.evaluation.opening.InstructionRa_20", "stage8.evaluation.opening.InstructionRa_21", "stage8.evaluation.opening.InstructionRa_22", "stage8.evaluation.opening.InstructionRa_23", "stage8.evaluation.opening.InstructionRa_24", "stage8.evaluation.opening.InstructionRa_25", "stage8.evaluation.opening.InstructionRa_26", "stage8.evaluation.opening.InstructionRa_27", "stage8.evaluation.opening.InstructionRa_28", "stage8.evaluation.opening.InstructionRa_29", "stage8.evaluation.opening.InstructionRa_30", "stage8.evaluation.opening.InstructionRa_31", "stage8.evaluation.opening.BytecodeRa_0", "stage8.evaluation.opening.BytecodeRa_1", "stage8.evaluation.opening.BytecodeRa_2", "stage8.evaluation.opening.RamRa_0", "stage8.evaluation.opening.RamRa_1", "stage8.evaluation.opening.RamRa_2", "stage8.evaluation.opening.RamRa_3"];
-
-pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan { symbol: "stage8.evaluation.openings", proof_slot: "stage8.evaluation", policy: "jolt_stage8_joint_rlc", count: 41, ordered_claims: STAGE8_OPENING_BATCH_ORDERED_CLAIMS };
+#[rustfmt::skip]
+pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan { symbol: Stage8OpeningBatchSymbol::new("stage8.evaluation.openings"), proof_slot: "stage8.evaluation", policy: "jolt_stage8_joint_rlc", count: 41, ordered_claims: STAGE8_OPENING_CLAIMS };
 
-pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan { symbol: "stage8.evaluation.proof", mode: "open", pcs: "dory", proof_slot: "stage8.evaluation", transcript_label: "rlc_claims", batch: "stage8.evaluation.openings" };
+#[rustfmt::skip]
+pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan { symbol: "stage8.evaluation.proof", mode: Stage8PcsProofMode::Open, pcs: "dory", proof_slot: "stage8.evaluation", transcript_label: "rlc_claims", batch: Stage8OpeningBatchSymbol::new("stage8.evaluation.openings") };
 
-pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan {
-    role: "prover",
-    function: "jolt.stage8",
-    params: STAGE8_PARAMS,
-    evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE,
-    opening_inputs: STAGE8_OPENING_INPUTS,
-    opening_claims: STAGE8_OPENING_CLAIMS,
-    opening_batch: STAGE8_OPENING_BATCH,
-    pcs_proof: STAGE8_PCS_PROOF,
-};
+#[rustfmt::skip]
+pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan { role: "prover", function: "jolt.stage8", params: STAGE8_PARAMS, evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE, opening_inputs: STAGE8_OPENING_INPUTS, opening_claims: STAGE8_OPENING_CLAIMS, opening_batch: STAGE8_OPENING_BATCH, pcs_proof: STAGE8_PCS_PROOF };
diff --git a/crates/jolt-verifier/Cargo.toml b/crates/jolt-verifier/Cargo.toml
index 3b6ecdafd5..c72cb32cb6 100644
--- a/crates/jolt-verifier/Cargo.toml
+++ b/crates/jolt-verifier/Cargo.toml
@@ -10,6 +10,7 @@ repository = "https://github.com/a16z/jolt"
 workspace = true
 
 [dependencies]
+bolt-verifier-runtime.workspace = true
 jolt-dory.workspace = true
 jolt-field.workspace = true
 jolt-lookup-tables.workspace = true
@@ -17,5 +18,4 @@ jolt-openings.workspace = true
 jolt-poly.workspace = true
 jolt-sumcheck.workspace = true
 jolt-transcript.workspace = true
-serde.workspace = true
 tracing.workspace = true
diff --git a/crates/jolt-verifier/src/lib.rs b/crates/jolt-verifier/src/lib.rs
index c9dfdffc26..90f218a585 100644
--- a/crates/jolt-verifier/src/lib.rs
+++ b/crates/jolt-verifier/src/lib.rs
@@ -17,12 +17,16 @@ pub use verifier::{
     verify_jolt_prefix_with_programs, verify_jolt_through_stage5,
     verify_jolt_through_stage5_with_programs, verify_jolt_through_stage6,
     verify_jolt_through_stage6_with_programs, verify_jolt_through_stage7,
-    verify_jolt_through_stage7_with_programs, verify_jolt_with_programs, JoltEvaluationProof,
-    JoltEvaluationProofError, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData,
-    JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData,
-    JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts,
-    JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, JoltVerificationArtifacts,
-    JoltVerifierInputs, JoltVerifierPrograms, JoltVerifierTarget, JoltVerifyError,
+    verify_jolt_through_stage7_with_programs, verify_jolt_with_programs, JoltEvaluationPolicy,
+    JoltEvaluationProof, JoltEvaluationProofError, JoltNamedEval, JoltProof, JoltProofSlot,
+    JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry,
+    JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector,
+    JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput,
+    JoltVerificationArtifacts, JoltVerifierCheckpoint, JoltVerifierInputs,
+    JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepKind,
+    JoltVerifierStepPlan, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError,
+    JOLT_TARGET_FULL, JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6,
+    JOLT_TARGET_THROUGH_STAGE7, JOLT_VERIFIER_STEPS, JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM,
 };
 
 pub const TRANSCRIPT_LABEL: &[u8] = b"Jolt";
diff --git a/crates/jolt-verifier/src/stages/commitment.rs b/crates/jolt-verifier/src/stages/commitment.rs
index ea31591867..f38a8ef072 100644
--- a/crates/jolt-verifier/src/stages/commitment.rs
+++ b/crates/jolt-verifier/src/stages/commitment.rs
@@ -137,46 +137,11 @@ pub const ORACLE_PLANS: &[OraclePlan] = &[
     OraclePlan { oracle: "TrustedAdvice", domain: "jolt.trace_domain", num_vars: 16 },
 ];
 pub const COMMITMENT_BATCH_0_ORACLES: &[&str] = &[
-    "RdInc",
-    "RamInc",
-    "InstructionRa_0",
-    "InstructionRa_1",
-    "InstructionRa_2",
-    "InstructionRa_3",
-    "InstructionRa_4",
-    "InstructionRa_5",
-    "InstructionRa_6",
-    "InstructionRa_7",
-    "InstructionRa_8",
-    "InstructionRa_9",
-    "InstructionRa_10",
-    "InstructionRa_11",
-    "InstructionRa_12",
-    "InstructionRa_13",
-    "InstructionRa_14",
-    "InstructionRa_15",
-    "InstructionRa_16",
-    "InstructionRa_17",
-    "InstructionRa_18",
-    "InstructionRa_19",
-    "InstructionRa_20",
-    "InstructionRa_21",
-    "InstructionRa_22",
-    "InstructionRa_23",
-    "InstructionRa_24",
-    "InstructionRa_25",
-    "InstructionRa_26",
-    "InstructionRa_27",
-    "InstructionRa_28",
-    "InstructionRa_29",
-    "InstructionRa_30",
-    "InstructionRa_31",
-    "RamRa_0",
-    "RamRa_1",
-    "RamRa_2",
-    "RamRa_3",
-    "BytecodeRa_0",
-    "BytecodeRa_1",
+    "RdInc", "RamInc", "InstructionRa_0", "InstructionRa_1", "InstructionRa_2", "InstructionRa_3", "InstructionRa_4", "InstructionRa_5",
+    "InstructionRa_6", "InstructionRa_7", "InstructionRa_8", "InstructionRa_9", "InstructionRa_10", "InstructionRa_11", "InstructionRa_12", "InstructionRa_13",
+    "InstructionRa_14", "InstructionRa_15", "InstructionRa_16", "InstructionRa_17", "InstructionRa_18", "InstructionRa_19", "InstructionRa_20", "InstructionRa_21",
+    "InstructionRa_22", "InstructionRa_23", "InstructionRa_24", "InstructionRa_25", "InstructionRa_26", "InstructionRa_27", "InstructionRa_28", "InstructionRa_29",
+    "InstructionRa_30", "InstructionRa_31", "RamRa_0", "RamRa_1", "RamRa_2", "RamRa_3", "BytecodeRa_0", "BytecodeRa_1",
     "BytecodeRa_2",
 ];
 pub const COMMITMENT_BATCH_PLANS: &[CommitmentBatchPlan] = &[
diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs
deleted file mode 100644
index 493e9e9395..0000000000
--- a/crates/jolt-verifier/src/stages/common.rs
+++ /dev/null
@@ -1,1789 +0,0 @@
-#![expect(
-    clippy::too_many_arguments,
-    reason = "generated verifier helpers mirror staged protocol ABIs"
-)]
-
-use jolt_field::{Field, Fr, MulPow2, RingCore};
-use jolt_poly::EqPolynomial;
-use jolt_sumcheck::{
-    CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier,
-};
-use jolt_transcript::{Label, Transcript};
-use serde::Serialize;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageParams {
-    pub field: &'static str,
-    pub pcs: &'static str,
-    pub transcript: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct KernelPlan {
-    pub symbol: &'static str,
-    pub relation: &'static str,
-    pub kind: &'static str,
-    pub backend: &'static str,
-    pub abi: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct TranscriptSqueezePlan {
-    pub symbol: &'static str,
-    pub label: &'static str,
-    pub kind: &'static str,
-    pub count: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct TranscriptAbsorbBytesPlan {
-    pub symbol: &'static str,
-    pub label: &'static str,
-    pub payload: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct ProgramStepPlan {
-    pub kind: &'static str,
-    pub symbol: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct OpeningInputPlan {
-    pub symbol: &'static str,
-    pub source_stage: &'static str,
-    pub source_claim: &'static str,
-    pub oracle: &'static str,
-    pub domain: &'static str,
-    pub point_arity: usize,
-    pub claim_kind: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct FieldConstantPlan {
-    pub symbol: &'static str,
-    pub field: &'static str,
-    pub value: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct FieldExprPlan {
-    pub symbol: &'static str,
-    pub kind: &'static str,
-    pub formula: &'static str,
-    pub operands: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckClaimPlan {
-    pub symbol: &'static str,
-    pub stage: &'static str,
-    pub domain: &'static str,
-    pub num_rounds: usize,
-    pub degree: usize,
-    pub claim: &'static str,
-    pub kernel: Option<&'static str>,
-    pub relation: Option<&'static str>,
-    pub claim_value: &'static str,
-    pub input_openings: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckBatchPlan {
-    pub symbol: &'static str,
-    pub stage: &'static str,
-    pub proof_slot: &'static str,
-    pub policy: &'static str,
-    pub count: usize,
-    pub ordered_claims: &'static str,
-    pub claim_operands: &'static str,
-    pub claim_label: &'static str,
-    pub round_label: &'static str,
-    pub round_schedule: &'static [usize],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckDriverPlan {
-    pub symbol: &'static str,
-    pub stage: &'static str,
-    pub proof_slot: &'static str,
-    pub kernel: Option<&'static str>,
-    pub relation: Option<&'static str>,
-    pub batch: &'static str,
-    pub policy: &'static str,
-    pub round_schedule: &'static [usize],
-    pub claim_label: &'static str,
-    pub round_label: &'static str,
-    pub num_rounds: usize,
-    pub degree: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckInstanceResultPlan {
-    pub symbol: &'static str,
-    pub source: &'static str,
-    pub claim: &'static str,
-    pub relation: &'static str,
-    pub index: usize,
-    pub point_arity: usize,
-    pub num_rounds: usize,
-    pub round_offset: usize,
-    pub point_order: &'static str,
-    pub degree: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SumcheckEvalPlan {
-    pub symbol: &'static str,
-    pub source: &'static str,
-    pub name: &'static str,
-    pub index: usize,
-    pub oracle: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct PointZeroPlan {
-    pub symbol: &'static str,
-    pub field: &'static str,
-    pub arity: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct PointSlicePlan {
-    pub symbol: &'static str,
-    pub source: &'static str,
-    pub offset: usize,
-    pub length: usize,
-    pub input: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct PointConcatPlan {
-    pub symbol: &'static str,
-    pub layout: &'static str,
-    pub arity: usize,
-    pub inputs: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct OpeningClaimPlan {
-    pub symbol: &'static str,
-    pub oracle: &'static str,
-    pub domain: &'static str,
-    pub point_arity: usize,
-    pub claim_kind: &'static str,
-    pub point_source: &'static str,
-    pub eval_source: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct OpeningClaimEqualityPlan {
-    pub symbol: &'static str,
-    pub mode: &'static str,
-    pub lhs: &'static str,
-    pub rhs: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct OpeningBatchPlan {
-    pub symbol: &'static str,
-    pub stage: &'static str,
-    pub proof_slot: &'static str,
-    pub policy: &'static str,
-    pub count: usize,
-    pub ordered_claims: &'static str,
-    pub claim_operands: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageProgramPlan {
-    pub role: &'static str,
-    pub params: StageParams,
-    pub steps: &'static [ProgramStepPlan],
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub transcript_absorb_bytes: &'static [TranscriptAbsorbBytesPlan],
-    pub opening_inputs: &'static [OpeningInputPlan],
-    pub field_constants: &'static [FieldConstantPlan],
-    pub field_exprs: &'static [FieldExprPlan],
-    pub kernels: &'static [KernelPlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub point_zeros: &'static [PointZeroPlan],
-    pub point_slices: &'static [PointSlicePlan],
-    pub point_concats: &'static [PointConcatPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_equalities: &'static [OpeningClaimEqualityPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageProgramPlanNoPointZeros {
-    pub role: &'static str,
-    pub params: StageParams,
-    pub steps: &'static [ProgramStepPlan],
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub transcript_absorb_bytes: &'static [TranscriptAbsorbBytesPlan],
-    pub opening_inputs: &'static [OpeningInputPlan],
-    pub field_constants: &'static [FieldConstantPlan],
-    pub field_exprs: &'static [FieldExprPlan],
-    pub kernels: &'static [KernelPlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub point_slices: &'static [PointSlicePlan],
-    pub point_concats: &'static [PointConcatPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_equalities: &'static [OpeningClaimEqualityPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageVerifierProgramPlan {
-    pub params: StageParams,
-    pub steps: &'static [ProgramStepPlan],
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub opening_inputs: &'static [OpeningInputPlan],
-    pub field_constants: &'static [FieldConstantPlan],
-    pub field_exprs: &'static [FieldExprPlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub point_slices: &'static [PointSlicePlan],
-    pub point_concats: &'static [PointConcatPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_equalities: &'static [OpeningClaimEqualityPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct StageVerifierProgramPlanNoEqualities {
-    pub params: StageParams,
-    pub steps: &'static [ProgramStepPlan],
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub opening_inputs: &'static [OpeningInputPlan],
-    pub field_constants: &'static [FieldConstantPlan],
-    pub field_exprs: &'static [FieldExprPlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub point_slices: &'static [PointSlicePlan],
-    pub point_concats: &'static [PointConcatPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct VerifierProgramPlanMinimal {
-    pub params: StageParams,
-    pub transcript_squeezes: &'static [TranscriptSqueezePlan],
-    pub claims: &'static [SumcheckClaimPlan],
-    pub batches: &'static [SumcheckBatchPlan],
-    pub drivers: &'static [SumcheckDriverPlan],
-    pub instance_results: &'static [SumcheckInstanceResultPlan],
-    pub evals: &'static [SumcheckEvalPlan],
-    pub opening_claims: &'static [OpeningClaimPlan],
-    pub opening_batches: &'static [OpeningBatchPlan],
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
-pub struct StageNamedEval<F: Field> {
-    pub name: &'static str,
-    pub oracle: &'static str,
-    pub value: F,
-}
-
-#[derive(Clone, Debug, Serialize)]
-pub struct StageSumcheckOutput<F: Field> {
-    pub driver: &'static str,
-    pub point: Vec<F>,
-    pub evals: Vec<StageNamedEval<F>>,
-    pub proof: SumcheckProof<F>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct StageChallengeVector<F: Field> {
-    pub symbol: &'static str,
-    pub values: Vec<F>,
-}
-
-#[derive(Clone, Debug)]
-pub struct StageExecutionArtifacts<F: Field> {
-    pub challenge_vectors: Vec<StageChallengeVector<F>>,
-    pub sumchecks: Vec<StageSumcheckOutput<F>>,
-    pub opening_batches: Vec<&'static OpeningBatchPlan>,
-}
-
-impl<F: Field> Default for StageExecutionArtifacts<F> {
-    fn default() -> Self {
-        Self {
-            challenge_vectors: Vec::new(),
-            sumchecks: Vec::new(),
-            opening_batches: Vec::new(),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct StageProof<F: Field> {
-    pub sumchecks: Vec<StageSumcheckOutput<F>>,
-}
-
-#[derive(Clone, Debug)]
-pub struct StageOpeningInputValue<F: Field> {
-    pub symbol: &'static str,
-    pub point: Vec<F>,
-    pub eval: F,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum RuntimePlanError {
-    MissingBatch {
-        driver: &'static str,
-        batch: &'static str,
-    },
-    MissingClaim {
-        batch: &'static str,
-        claim: &'static str,
-    },
-    MissingValue {
-        symbol: &'static str,
-    },
-    InvalidInputLength {
-        input: &'static str,
-        expected: usize,
-        actual: usize,
-    },
-    InvalidProof {
-        driver: &'static str,
-        reason: &'static str,
-    },
-    UnsupportedFieldExpr {
-        symbol: &'static str,
-        formula: &'static str,
-    },
-}
-
-macro_rules! impl_runtime_plan_error_conversion {
-    ($error:ident) => {
-        impl From<super::common::RuntimePlanError> for $error {
-            fn from(error: super::common::RuntimePlanError) -> Self {
-                match error {
-                    super::common::RuntimePlanError::MissingBatch { driver, batch } => {
-                        Self::MissingBatch { driver, batch }
-                    }
-                    super::common::RuntimePlanError::MissingClaim { batch, claim } => {
-                        Self::MissingClaim { batch, claim }
-                    }
-                    super::common::RuntimePlanError::MissingValue { symbol } => {
-                        Self::MissingValue { symbol }
-                    }
-                    super::common::RuntimePlanError::InvalidInputLength {
-                        input,
-                        expected,
-                        actual,
-                    } => Self::InvalidInputLength {
-                        input,
-                        expected,
-                        actual,
-                    },
-                    super::common::RuntimePlanError::InvalidProof { driver, reason } => {
-                        Self::InvalidProof { driver, reason }
-                    }
-                    super::common::RuntimePlanError::UnsupportedFieldExpr { symbol, formula } => {
-                        Self::UnsupportedFieldExpr { symbol, formula }
-                    }
-                }
-            }
-        }
-    };
-}
-
-pub(crate) use impl_runtime_plan_error_conversion;
-
-pub trait SymbolPlan {
-    fn symbol(&self) -> &'static str;
-}
-
-impl SymbolPlan for TranscriptSqueezePlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for TranscriptAbsorbBytesPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for SumcheckBatchPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for SumcheckClaimPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for SumcheckDriverPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-impl SymbolPlan for OpeningClaimPlan {
-    fn symbol(&self) -> &'static str {
-        self.symbol
-    }
-}
-
-pub trait SumcheckClaimInfo: SymbolPlan {
-    fn num_rounds(&self) -> usize;
-    fn claim_value(&self) -> &'static str;
-}
-
-impl SumcheckClaimInfo for SumcheckClaimPlan {
-    fn num_rounds(&self) -> usize {
-        self.num_rounds
-    }
-
-    fn claim_value(&self) -> &'static str {
-        self.claim_value
-    }
-}
-
-pub trait SumcheckDriverInfo: SymbolPlan {
-    fn batch(&self) -> &'static str;
-    fn num_rounds(&self) -> usize;
-    fn degree(&self) -> usize;
-    fn round_label(&self) -> &'static str;
-}
-
-impl SumcheckDriverInfo for SumcheckDriverPlan {
-    fn batch(&self) -> &'static str {
-        self.batch
-    }
-
-    fn num_rounds(&self) -> usize {
-        self.num_rounds
-    }
-
-    fn degree(&self) -> usize {
-        self.degree
-    }
-
-    fn round_label(&self) -> &'static str {
-        self.round_label
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct ValueStore<F: Field> {
-    scalars: Vec<(&'static str, F)>,
-    points: Vec<(&'static str, Vec<F>)>,
-}
-
-impl<F: Field> ValueStore<F> {
-    pub fn with_opening_inputs(
-        inputs: &[StageOpeningInputValue<F>],
-        expected_inputs: &[OpeningInputPlan],
-    ) -> Result<Self, RuntimePlanError> {
-        if inputs.len() != expected_inputs.len() {
-            return Err(RuntimePlanError::InvalidInputLength {
-                input: "opening_inputs",
-                expected: expected_inputs.len(),
-                actual: inputs.len(),
-            });
-        }
-        for expected in expected_inputs {
-            let matching_count = inputs
-                .iter()
-                .filter(|input| input.symbol == expected.symbol)
-                .count();
-            if matching_count != 1 {
-                return Err(RuntimePlanError::InvalidInputLength {
-                    input: expected.symbol,
-                    expected: 1,
-                    actual: matching_count,
-                });
-            }
-            if let Some(input) = inputs.iter().find(|input| input.symbol == expected.symbol) {
-                if input.point.len() != expected.point_arity {
-                    return Err(RuntimePlanError::InvalidInputLength {
-                        input: expected.symbol,
-                        expected: expected.point_arity,
-                        actual: input.point.len(),
-                    });
-                }
-            }
-        }
-        let mut store = Self::default();
-        for input in inputs {
-            store.insert_scalar(input.symbol, input.eval);
-            store.insert_point(input.symbol, input.point.clone());
-        }
-        Ok(store)
-    }
-
-    pub fn seed_constants(&mut self, constants: &[FieldConstantPlan]) {
-        for constant in constants {
-            self.insert_scalar(constant.symbol, F::from_u64(constant.value as u64));
-        }
-    }
-
-    pub fn seed_point_zeros(&mut self, point_zeros: &[PointZeroPlan]) {
-        for zero in point_zeros {
-            self.insert_point(zero.symbol, vec![F::from_u64(0); zero.arity]);
-        }
-    }
-
-    pub fn observe_challenge_vector<E>(
-        &mut self,
-        plan: &TranscriptSqueezePlan,
-        values: &[F],
-        invalid_input_length: impl Fn(&'static str, usize, usize) -> E,
-    ) -> Result<(), E> {
-        self.insert_point(plan.symbol, values.to_vec());
-        if matches!(plan.kind, "challenge_scalar" | "scalar") {
-            if values.len() != 1 {
-                return Err(invalid_input_length(plan.symbol, 1, values.len()));
-            }
-            self.insert_scalar(plan.symbol, values[0]);
-        }
-        Ok(())
-    }
-
-    pub fn observe_sumcheck_output<E>(
-        &mut self,
-        instance_results: &[SumcheckInstanceResultPlan],
-        evals: &[SumcheckEvalPlan],
-        output: &StageSumcheckOutput<F>,
-        normalize_point: impl Fn(&SumcheckInstanceResultPlan, Vec<F>) -> Result<Vec<F>, E>,
-        invalid_input_length: impl Fn(&'static str, usize, usize) -> E,
-        missing_value: impl Fn(&'static str) -> E,
-    ) -> Result<(), E> {
-        self.insert_point(output.driver, output.point.clone());
-        for instance in instance_results
-            .iter()
-            .filter(|instance| instance.source == output.driver)
-        {
-            let end = instance.round_offset + instance.point_arity;
-            let point = output
-                .point
-                .get(instance.round_offset..end)
-                .ok_or_else(|| invalid_input_length(instance.symbol, end, output.point.len()))?
-                .to_vec();
-            self.insert_point(instance.symbol, normalize_point(instance, point)?);
-        }
-        for eval in evals.iter().filter(|eval| eval.source == output.driver) {
-            let value = output
-                .evals
-                .iter()
-                .find(|value| value.name == eval.name)
-                .or_else(|| output.evals.get(eval.index))
-                .ok_or_else(|| missing_value(eval.symbol))?
-                .value;
-            self.insert_scalar(eval.symbol, value);
-            self.insert_scalar(eval.name, value);
-        }
-        Ok(())
-    }
-
-    pub fn evaluate_available_points<E>(
-        &mut self,
-        point_slices: &[PointSlicePlan],
-        point_concats: &[PointConcatPlan],
-        invalid_input_length: impl Fn(&'static str, usize, usize) -> E,
-    ) -> Result<(), E> {
-        loop {
-            let mut progress = 0usize;
-            for slice in point_slices {
-                if self.try_point(slice.symbol).is_some() {
-                    continue;
-                }
-                let Some(input) = self.try_point(slice.input) else {
-                    continue;
-                };
-                let end = slice.offset + slice.length;
-                let point = input
-                    .get(slice.offset..end)
-                    .ok_or_else(|| invalid_input_length(slice.symbol, end, input.len()))?
-                    .to_vec();
-                self.insert_point(slice.symbol, point);
-                progress += 1;
-            }
-            for concat in point_concats {
-                if self.try_point(concat.symbol).is_some() {
-                    continue;
-                }
-                let Some(point) = self.try_concat_point(concat) else {
-                    continue;
-                };
-                if point.len() != concat.arity {
-                    return Err(invalid_input_length(
-                        concat.symbol,
-                        concat.arity,
-                        point.len(),
-                    ));
-                }
-                self.insert_point(concat.symbol, point);
-                progress += 1;
-            }
-            if progress == 0 {
-                return Ok(());
-            }
-        }
-    }
-
-    pub fn evaluate_available_field_exprs<E>(
-        &mut self,
-        field_exprs: &[FieldExprPlan],
-        evaluate: impl Fn(&FieldExprPlan, &[F]) -> Result<F, E>,
-    ) -> Result<(), E> {
-        loop {
-            let mut progress = 0usize;
-            for expr in field_exprs {
-                if self.try_scalar(expr.symbol).is_some() {
-                    continue;
-                }
-                let Some(operands) = self.try_expr_operands(expr) else {
-                    continue;
-                };
-                self.insert_scalar(expr.symbol, evaluate(expr, &operands)?);
-                progress += 1;
-            }
-            if progress == 0 {
-                return Ok(());
-            }
-        }
-    }
-
-    pub fn verify_opening_equalities<E>(
-        &self,
-        opening_equalities: &[OpeningClaimEqualityPlan],
-        invalid_proof: impl Fn(&'static str, &'static str) -> E,
-        missing_value: impl Fn(&'static str) -> E,
-    ) -> Result<(), E> {
-        for equality in opening_equalities {
-            match equality.mode {
-                "point_and_eval" => {
-                    if self.point_or(equality.lhs, &missing_value)?
-                        != self.point_or(equality.rhs, &missing_value)?
-                        || self.scalar_or(equality.lhs, &missing_value)?
-                            != self.scalar_or(equality.rhs, &missing_value)?
-                    {
-                        return Err(invalid_proof(
-                            equality.symbol,
-                            "opening claim equality failed",
-                        ));
-                    }
-                }
-                _ => {
-                    return Err(invalid_proof(
-                        equality.symbol,
-                        "unsupported opening equality mode",
-                    ));
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub fn insert_scalar(&mut self, symbol: &'static str, value: F) {
-        if let Some((_, existing)) = self.scalars.iter_mut().find(|(name, _)| *name == symbol) {
-            *existing = value;
-        } else {
-            self.scalars.push((symbol, value));
-        }
-    }
-
-    pub fn insert_point(&mut self, symbol: &'static str, point: Vec<F>) {
-        if let Some((_, existing)) = self.points.iter_mut().find(|(name, _)| *name == symbol) {
-            *existing = point;
-        } else {
-            self.points.push((symbol, point));
-        }
-    }
-
-    pub fn scalar_or<E>(
-        &self,
-        symbol: &'static str,
-        missing_value: impl FnOnce(&'static str) -> E,
-    ) -> Result<F, E> {
-        self.try_scalar(symbol).ok_or_else(|| missing_value(symbol))
-    }
-
-    pub fn try_scalar(&self, symbol: &str) -> Option<F> {
-        self.scalars
-            .iter()
-            .find(|(name, _)| *name == symbol)
-            .map(|(_, value)| *value)
-    }
-
-    pub fn point_or<E>(
-        &self,
-        symbol: &'static str,
-        missing_value: impl FnOnce(&'static str) -> E,
-    ) -> Result<&[F], E> {
-        self.try_point(symbol).ok_or_else(|| missing_value(symbol))
-    }
-
-    pub fn try_point(&self, symbol: &str) -> Option<&[F]> {
-        self.points
-            .iter()
-            .find(|(name, _)| *name == symbol)
-            .map(|(_, point)| point.as_slice())
-    }
-
-    fn try_expr_operands(&self, expr: &FieldExprPlan) -> Option<Vec<F>> {
-        if expr.operands.is_empty() {
-            return Some(Vec::new());
-        }
-        expr.operands
-            .split('|')
-            .map(|operand| self.try_scalar(operand))
-            .collect()
-    }
-
-    fn try_concat_point(&self, concat: &PointConcatPlan) -> Option<Vec<F>> {
-        let mut point = Vec::with_capacity(concat.arity);
-        for input in symbol_list(concat.inputs) {
-            point.extend_from_slice(self.try_point(input)?);
-        }
-        Some(point)
-    }
-}
-
-pub fn symbol_list(symbols: &'static str) -> impl Iterator<Item = &'static str> {
-    symbols.split('|').filter(|symbol| !symbol.is_empty())
-}
-
-pub fn find_plan<'a, T: SymbolPlan>(plans: &'a [T], symbol: &str) -> Option<&'a T> {
-    plans.iter().find(|plan| plan.symbol() == symbol)
-}
-
-pub fn find_batch<'a>(
-    batches: &'a [SumcheckBatchPlan],
-    driver: &'static str,
-    batch: &'static str,
-) -> Result<&'a SumcheckBatchPlan, RuntimePlanError> {
-    find_plan(batches, batch).ok_or(RuntimePlanError::MissingBatch { driver, batch })
-}
-
-pub fn batch_claims<'a, C: SymbolPlan>(
-    claims: &'a [C],
-    batch: &SumcheckBatchPlan,
-) -> Result<Vec<&'a C>, RuntimePlanError> {
-    symbol_list(batch.claim_operands)
-        .map(|symbol| {
-            find_plan(claims, symbol).ok_or(RuntimePlanError::MissingClaim {
-                batch: batch.symbol,
-                claim: symbol,
-            })
-        })
-        .collect()
-}
-
-pub fn batch_claim_values<C: SumcheckClaimInfo>(
-    claims: &[&C],
-    field_exprs: &[FieldExprPlan],
-    store: &mut ValueStore<Fr>,
-) -> Result<Vec<Fr>, RuntimePlanError> {
-    claims
-        .iter()
-        .map(|claim| {
-            store.evaluate_available_field_exprs(field_exprs, evaluate_field_expr)?;
-            store.scalar_or(claim.claim_value(), |symbol| {
-                RuntimePlanError::MissingValue { symbol }
-            })
-        })
-        .collect()
-}
-
-pub fn verify_batched_sumcheck<T, E, C, D, Expected, Observe, MapSumcheck>(
-    driver: &'static D,
-    proof: &StageSumcheckOutput<Fr>,
-    claims: &'static [C],
-    batches: &'static [SumcheckBatchPlan],
-    field_exprs: &'static [FieldExprPlan],
-    opening_inputs: &'static [OpeningInputPlan],
-    opening_claims: &'static [OpeningClaimPlan],
-    opening_batches: &'static [OpeningBatchPlan],
-    store: &mut ValueStore<Fr>,
-    transcript: &mut T,
-    expected_output: Expected,
-    observe_output: Observe,
-    map_sumcheck: MapSumcheck,
-) -> Result<StageSumcheckOutput<Fr>, E>
-where
-    T: Transcript<Challenge = Fr>,
-    E: From<RuntimePlanError>,
-    C: SumcheckClaimInfo,
-    D: SumcheckDriverInfo,
-    Expected: FnOnce(&ValueStore<Fr>, &[StageNamedEval<Fr>], &[Fr], &[Fr]) -> Result<Fr, E>,
-    Observe: FnOnce(&mut ValueStore<Fr>, &StageSumcheckOutput<Fr>) -> Result<(), E>,
-    MapSumcheck: FnOnce(&'static str, SumcheckError<Fr>) -> E,
-{
-    if proof.driver != driver.symbol() {
-        return Err(RuntimePlanError::InvalidProof {
-            driver: driver.symbol(),
-            reason: "driver symbol mismatch",
-        }
-        .into());
-    }
-    let batch = find_batch(batches, driver.symbol(), driver.batch())?;
-    let claims = batch_claims(claims, batch)?;
-    let input_claims = batch_claim_values(&claims, field_exprs, store)?;
-    for claim in &input_claims {
-        append_labeled_scalar(transcript, batch.claim_label, claim);
-    }
-    let batching_coeffs = transcript.challenge_vector(claims.len());
-    let claimed_sum = input_claims
-        .iter()
-        .zip(claims.iter())
-        .zip(&batching_coeffs)
-        .map(|((claim, plan), coefficient)| {
-            claim.mul_pow_2(driver.num_rounds() - plan.num_rounds()) * *coefficient
-        })
-        .sum::<Fr>();
-    let claim = SumcheckClaim::new(driver.num_rounds(), driver.degree(), claimed_sum);
-    let round_proofs = proof
-        .proof
-        .round_polynomials
-        .iter()
-        .map(|poly| CompressedLabeledRoundPoly::new(poly, driver.round_label().as_bytes()))
-        .collect::<Vec<_>>();
-    let output = SumcheckVerifier::verify_optimized(&claim, &round_proofs, transcript)
-        .map_err(|error| map_sumcheck(driver.symbol(), error))?;
-    if !proof.point.is_empty() && proof.point != output.point {
-        return Err(RuntimePlanError::InvalidProof {
-            driver: driver.symbol(),
-            reason: "batched point mismatch",
-        }
-        .into());
-    }
-    let expected = expected_output(store, &proof.evals, &output.point, &batching_coeffs)?;
-    if output.value != expected {
-        return Err(RuntimePlanError::InvalidProof {
-            driver: driver.symbol(),
-            reason: "batched output claim mismatch",
-        }
-        .into());
-    }
-    let verified = StageSumcheckOutput {
-        driver: driver.symbol(),
-        point: output.point,
-        evals: proof.evals.clone(),
-        proof: proof.proof.clone(),
-    };
-    observe_output(store, &verified)?;
-    append_opening_claims(
-        opening_inputs,
-        opening_claims,
-        opening_batches,
-        store,
-        transcript,
-        &verified.evals,
-        |batch, claim| RuntimePlanError::MissingClaim { batch, claim },
-        |symbol| RuntimePlanError::MissingValue { symbol },
-    )?;
-    Ok(verified)
-}
-
-pub fn eval_by_name<F: Field>(
-    evals: &[StageNamedEval<F>],
-    name: &'static str,
-) -> Result<F, RuntimePlanError> {
-    evals
-        .iter()
-        .find(|eval| eval.name == name)
-        .map(|eval| eval.value)
-        .ok_or(RuntimePlanError::MissingValue { symbol: name })
-}
-
-pub fn indexed_evals_by_prefix<F: Field>(
-    evals: &[StageNamedEval<F>],
-    prefix: &'static str,
-    count: usize,
-) -> Result<Vec<F>, RuntimePlanError> {
-    let mut values = vec![None; count];
-    for eval in evals {
-        let Some(suffix) = eval.name.strip_prefix(prefix) else {
-            continue;
-        };
-        let index = suffix
-            .parse::<usize>()
-            .map_err(|_| RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "invalid indexed eval suffix",
-            })?;
-        if index >= count || values[index].is_some() {
-            return Err(RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "invalid indexed eval",
-            });
-        }
-        values[index] = Some(eval.value);
-    }
-    values
-        .into_iter()
-        .map(|value| value.ok_or(RuntimePlanError::MissingValue { symbol: prefix }))
-        .collect()
-}
-
-pub fn indexed_evals_by_prefix_any<F: Field>(
-    evals: &[StageNamedEval<F>],
-    prefix: &'static str,
-) -> Result<Vec<F>, RuntimePlanError> {
-    let mut indexed_values = Vec::new();
-    for eval in evals {
-        let Some(suffix) = eval.name.strip_prefix(prefix) else {
-            continue;
-        };
-        let index = suffix
-            .parse::<usize>()
-            .map_err(|_| RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "invalid indexed eval suffix",
-            })?;
-        if indexed_values
-            .iter()
-            .any(|(existing_index, _)| *existing_index == index)
-        {
-            return Err(RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "duplicate indexed eval",
-            });
-        }
-        indexed_values.push((index, eval.value));
-    }
-    if indexed_values.is_empty() {
-        return Err(RuntimePlanError::MissingValue { symbol: prefix });
-    }
-    indexed_values.sort_by_key(|(index, _)| *index);
-    for (expected, (actual, _)) in indexed_values.iter().enumerate() {
-        if *actual != expected {
-            return Err(RuntimePlanError::InvalidProof {
-                driver: prefix,
-                reason: "non-contiguous indexed eval",
-            });
-        }
-    }
-    Ok(indexed_values.into_iter().map(|(_, value)| value).collect())
-}
-
-pub fn single_operand<F: Field>(
-    symbol: &'static str,
-    operands: &[F],
-) -> Result<F, RuntimePlanError> {
-    require_operand_count(symbol, 1, operands.len())?;
-    Ok(operands[0])
-}
-
-pub fn require_operand_count(
-    input: &'static str,
-    expected: usize,
-    actual: usize,
-) -> Result<(), RuntimePlanError> {
-    if expected == actual {
-        Ok(())
-    } else {
-        Err(RuntimePlanError::InvalidInputLength {
-            input,
-            expected,
-            actual,
-        })
-    }
-}
-
-pub fn evaluate_field_expr<F: Field>(
-    expr: &FieldExprPlan,
-    operands: &[F],
-) -> Result<F, RuntimePlanError> {
-    match expr.formula {
-        "opening_eval" => Ok(single_operand(expr.symbol, operands)?),
-        "field.add" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] + operands[1])
-        }
-        "field.sub" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] - operands[1])
-        }
-        "field.mul" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] * operands[1])
-        }
-        "field.neg" => {
-            require_operand_count(expr.symbol, 1, operands.len())?;
-            Ok(-operands[0])
-        }
-        formula => {
-            if let Some(exponent) = formula.strip_prefix("field.pow:") {
-                require_operand_count(expr.symbol, 1, operands.len())?;
-                let exponent = exponent.parse::<usize>().map_err(|_| {
-                    RuntimePlanError::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                return Ok(pow_field(operands[0], exponent));
-            }
-            Err(RuntimePlanError::UnsupportedFieldExpr {
-                symbol: expr.symbol,
-                formula,
-            })
-        }
-    }
-}
-
-pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] {
-    let mut powers = [Fr::from_u64(1); 8];
-    for index in 1..powers.len() {
-        powers[index] = powers[index - 1] * gamma;
-    }
-    powers
-}
-
-pub fn indexed_boolean_eq(index: usize, point: &[Fr]) -> Fr {
-    point
-        .iter()
-        .enumerate()
-        .map(|(bit, value)| {
-            if (index >> (point.len() - 1 - bit)) & 1 == 1 {
-                *value
-            } else {
-                Fr::from_u64(1) - *value
-            }
-        })
-        .product()
-}
-
-pub fn field_powers(base: Fr, count: usize) -> Vec<Fr> {
-    let mut powers = Vec::with_capacity(count);
-    let mut power = Fr::from_u64(1);
-    for _ in 0..count {
-        powers.push(power);
-        power *= base;
-    }
-    powers
-}
-
-pub fn prefix_point<'a, F: Field>(
-    point: &'a [F],
-    length: usize,
-    input: &'static str,
-) -> Result<&'a [F], RuntimePlanError> {
-    point
-        .get(..length)
-        .filter(|prefix| prefix.len() == length)
-        .ok_or(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: length,
-            actual: point.len(),
-        })
-}
-
-pub fn suffix_point<'a, F: Field>(
-    point: &'a [F],
-    length: usize,
-    input: &'static str,
-) -> Result<&'a [F], RuntimePlanError> {
-    point
-        .get(point.len().saturating_sub(length)..)
-        .filter(|suffix| suffix.len() == length)
-        .ok_or(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: length,
-            actual: point.len(),
-        })
-}
-
-pub fn normalize_bytecode_read_raf_point<F: Field>(
-    point: &[F],
-    log_t: usize,
-    input: &'static str,
-) -> Result<Vec<F>, RuntimePlanError> {
-    let log_k = point
-        .len()
-        .checked_sub(log_t)
-        .ok_or(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: log_t,
-            actual: point.len(),
-        })?;
-    let mut normalized = point.to_vec();
-    normalized[..log_k].reverse();
-    normalized[log_k..].reverse();
-    Ok(normalized)
-}
-
-pub fn normalize_instruction_read_raf_point<F: Field>(
-    point: &[F],
-    input: &'static str,
-) -> Result<Vec<F>, RuntimePlanError> {
-    const LOG_K: usize = 128;
-    if point.len() < LOG_K {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: LOG_K,
-            actual: point.len(),
-        });
-    }
-    let mut normalized = point.to_vec();
-    normalized[LOG_K..].reverse();
-    Ok(normalized)
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Stage67RelationSymbols {
-    pub hamming_booleanity_relation: &'static str,
-    pub hamming_booleanity_instance: &'static str,
-    pub booleanity_point: &'static str,
-    pub stage5_instruction_ra0: &'static str,
-    pub booleanity_combined_point: &'static str,
-    pub booleanity_gamma: &'static str,
-    pub booleanity_instruction_ra_prefix: &'static str,
-    pub booleanity_bytecode_ra_prefix: &'static str,
-    pub booleanity_ram_ra_prefix: &'static str,
-    pub hamming_weight_eval: &'static str,
-    pub hamming_lookup_output: &'static str,
-    pub ram_ra_virtual_cycle: &'static str,
-    pub ram_ra_virtual_eval_prefix: &'static str,
-    pub instruction_ra_virtual_cycle: &'static str,
-    pub instruction_ra_virtual_eval_prefix: &'static str,
-    pub instruction_ra_virtual_input_prefix: &'static str,
-    pub instruction_ra_virtual_gamma: &'static str,
-    pub inc_ram_stage2: &'static str,
-    pub inc_ram_stage4: &'static str,
-    pub inc_rd_stage4: &'static str,
-    pub inc_rd_stage5: &'static str,
-    pub inc_gamma: &'static str,
-    pub inc_ram_eval: &'static str,
-    pub inc_rd_eval: &'static str,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Stage67BytecodeSymbols {
-    pub point: &'static str,
-    pub gamma: &'static str,
-    pub bytecode_ra_eval_prefix: &'static str,
-    pub entries: &'static str,
-    pub entry_bytecode_index: &'static str,
-    pub stage_gammas: [&'static str; 5],
-    pub stage_cycle_points: [&'static str; 5],
-    pub stage4_register_point: &'static str,
-    pub stage5_register_point: &'static str,
-    pub entry_rd: &'static str,
-    pub entry_rs1: &'static str,
-    pub entry_rs2: &'static str,
-    pub entry_lookup_table: &'static str,
-}
-
-pub trait Stage67BytecodeEntry {
-    fn address(&self) -> Fr;
-    fn imm(&self) -> Fr;
-    fn circuit_flags(&self) -> &[bool; 14];
-    fn rd(&self) -> Option<usize>;
-    fn rs1(&self) -> Option<usize>;
-    fn rs2(&self) -> Option<usize>;
-    fn lookup_table(&self) -> Option<usize>;
-    fn is_interleaved(&self) -> bool;
-    fn is_branch(&self) -> bool;
-    fn left_is_rs1(&self) -> bool;
-    fn left_is_pc(&self) -> bool;
-    fn right_is_rs2(&self) -> bool;
-    fn right_is_imm(&self) -> bool;
-    fn is_noop(&self) -> bool;
-}
-
-pub fn store_scalar(store: &ValueStore<Fr>, symbol: &'static str) -> Result<Fr, RuntimePlanError> {
-    store.scalar_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol })
-}
-
-pub fn store_point<'a>(
-    store: &'a ValueStore<Fr>,
-    symbol: &'static str,
-) -> Result<&'a [Fr], RuntimePlanError> {
-    store.point_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol })
-}
-
-pub fn stage67_trace_rounds(
-    instance_results: &[SumcheckInstanceResultPlan],
-    symbols: &Stage67RelationSymbols,
-) -> Result<usize, RuntimePlanError> {
-    instance_results
-        .iter()
-        .find(|instance| instance.relation == symbols.hamming_booleanity_relation)
-        .map(|instance| instance.num_rounds)
-        .ok_or(RuntimePlanError::MissingValue {
-            symbol: symbols.hamming_booleanity_instance,
-        })
-}
-
-pub fn expected_stage67_bytecode_read_raf<E: Stage67BytecodeEntry>(
-    entries: &[E],
-    entry_bytecode_index: usize,
-    num_lookup_tables: usize,
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    log_t: usize,
-    symbols: &Stage67BytecodeSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, symbols.point)?;
-    let log_k = opening_point.len() - log_t;
-    let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k);
-
-    let gamma = store_scalar(store, symbols.gamma)?;
-    let gamma_powers = bytecode_gamma_powers(gamma);
-    let int_eval = identity_polynomial_eval(r_address_prime);
-    let stage_value_evals = stage67_bytecode_stage_value_evals(
-        entries,
-        entry_bytecode_index,
-        num_lookup_tables,
-        store,
-        r_address_prime,
-        r_cycle_prime.len(),
-        symbols,
-    )?;
-    let stage_cycle_points =
-        stage67_bytecode_stage_cycle_points(store, r_cycle_prime.len(), symbols)?;
-    let int_contrib = [
-        gamma_powers[5] * int_eval,
-        Fr::from_u64(0),
-        gamma_powers[4] * int_eval,
-        Fr::from_u64(0),
-        Fr::from_u64(0),
-    ];
-
-    let mut val = Fr::from_u64(0);
-    for index in 0..stage_value_evals.len() {
-        val += (stage_value_evals[index] + int_contrib[index])
-            * EqPolynomial::<Fr>::mle(&stage_cycle_points[index], r_cycle_prime)
-            * gamma_powers[index];
-    }
-
-    let entry_bits = (0..log_k)
-        .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64))
-        .collect::<Vec<_>>();
-    let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()];
-    let entry_contrib = gamma_powers[7]
-        * EqPolynomial::<Fr>::mle(&entry_bits, r_address_prime)
-        * EqPolynomial::<Fr>::mle(&zero_cycle, r_cycle_prime);
-    let bytecode_ra = indexed_evals_by_prefix_any(evals, symbols.bytecode_ra_eval_prefix)?
-        .into_iter()
-        .product::<Fr>();
-    Ok((val + entry_contrib) * bytecode_ra)
-}
-
-pub fn expected_stage67_booleanity(
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    log_t: usize,
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let log_k_chunk =
-        local_point
-            .len()
-            .checked_sub(log_t)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input: symbols.booleanity_point,
-                expected: log_t,
-                actual: local_point.len(),
-            })?;
-    let stage5_point = store_point(store, symbols.stage5_instruction_ra0)?;
-    let stage5_address_len =
-        stage5_point
-            .len()
-            .checked_sub(log_t)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input: symbols.stage5_instruction_ra0,
-                expected: log_t,
-                actual: stage5_point.len(),
-            })?;
-    if stage5_address_len < log_k_chunk {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.stage5_instruction_ra0,
-            expected: log_k_chunk + log_t,
-            actual: stage5_point.len(),
-        });
-    }
-
-    let mut stage5_addr = stage5_point[..stage5_address_len].to_vec();
-    stage5_addr.reverse();
-    let mut combined_r = stage5_addr[stage5_address_len - log_k_chunk..].to_vec();
-    combined_r.extend(stage5_point[stage5_address_len..].iter().rev().copied());
-    if combined_r.len() != local_point.len() {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.booleanity_combined_point,
-            expected: local_point.len(),
-            actual: combined_r.len(),
-        });
-    }
-    let mut verifier_point = combined_r[..log_k_chunk].to_vec();
-    verifier_point.reverse();
-    verifier_point.extend(combined_r[log_k_chunk..].iter().rev().copied());
-    let eq_eval = EqPolynomial::<Fr>::mle(local_point, &verifier_point);
-
-    let gamma = store_scalar(store, symbols.booleanity_gamma)?;
-    let gamma_sq = gamma.square();
-    let mut gamma_power = Fr::from_u64(1);
-    let mut booleanity = Fr::from_u64(0);
-    for ra in stage67_booleanity_evals(evals, symbols)? {
-        booleanity += gamma_power * (ra.square() - ra);
-        gamma_power *= gamma_sq;
-    }
-    Ok(eq_eval * booleanity)
-}
-
-pub fn expected_stage67_hamming_booleanity(
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let hamming = eval_by_name(evals, symbols.hamming_weight_eval)?;
-    let lookup_output_point = reverse_slice(store_point(store, symbols.hamming_lookup_output)?);
-    if lookup_output_point.len() != local_point.len() {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.hamming_lookup_output,
-            expected: local_point.len(),
-            actual: lookup_output_point.len(),
-        });
-    }
-    let eq_eval = EqPolynomial::<Fr>::mle(local_point, &lookup_output_point);
-    Ok((hamming.square() - hamming) * eq_eval)
-}
-
-pub fn expected_stage67_ram_ra_virtual(
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let r_cycle_reduced = reverse_slice(local_point);
-    let r_cycle = suffix_point(
-        store_point(store, symbols.ram_ra_virtual_cycle)?,
-        r_cycle_reduced.len(),
-        symbols.ram_ra_virtual_cycle,
-    )?;
-    let eq_eval = EqPolynomial::<Fr>::mle(r_cycle, &r_cycle_reduced);
-    let ram_ra = indexed_evals_by_prefix_any(evals, symbols.ram_ra_virtual_eval_prefix)?
-        .into_iter()
-        .product::<Fr>();
-    Ok(eq_eval * ram_ra)
-}
-
-pub fn expected_stage67_instruction_ra_virtual(
-    opening_inputs: &[OpeningInputPlan],
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let r_cycle_reduced = reverse_slice(local_point);
-    let r_cycle = suffix_point(
-        store_point(store, symbols.instruction_ra_virtual_cycle)?,
-        r_cycle_reduced.len(),
-        symbols.instruction_ra_virtual_cycle,
-    )?;
-    let eq_eval = EqPolynomial::<Fr>::mle(r_cycle, &r_cycle_reduced);
-    let committed_ra =
-        indexed_evals_by_prefix_any(evals, symbols.instruction_ra_virtual_eval_prefix)?;
-    let virtual_count = opening_inputs
-        .iter()
-        .filter(|input| {
-            input
-                .symbol
-                .starts_with(symbols.instruction_ra_virtual_input_prefix)
-        })
-        .count();
-    if virtual_count == 0 || committed_ra.len() % virtual_count != 0 {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.instruction_ra_virtual_eval_prefix,
-            expected: virtual_count,
-            actual: committed_ra.len(),
-        });
-    }
-    let committed_per_virtual = committed_ra.len() / virtual_count;
-    let gamma = store_scalar(store, symbols.instruction_ra_virtual_gamma)?;
-    let mut gamma_power = Fr::from_u64(1);
-    let mut value = Fr::from_u64(0);
-    for chunk in committed_ra.chunks(committed_per_virtual) {
-        value += gamma_power * chunk.iter().copied().product::<Fr>();
-        gamma_power *= gamma;
-    }
-    Ok(eq_eval * value)
-}
-
-pub fn expected_stage67_inc_claim_reduction(
-    store: &ValueStore<Fr>,
-    evals: &[StageNamedEval<Fr>],
-    local_point: &[Fr],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Fr, RuntimePlanError> {
-    let r_cycle_reduced = reverse_slice(local_point);
-    let ram_inc_stage2 = suffix_point(
-        store_point(store, symbols.inc_ram_stage2)?,
-        r_cycle_reduced.len(),
-        symbols.inc_ram_stage2,
-    )?;
-    let ram_inc_stage4 = suffix_point(
-        store_point(store, symbols.inc_ram_stage4)?,
-        r_cycle_reduced.len(),
-        symbols.inc_ram_stage4,
-    )?;
-    let rd_inc_stage4 = suffix_point(
-        store_point(store, symbols.inc_rd_stage4)?,
-        r_cycle_reduced.len(),
-        symbols.inc_rd_stage4,
-    )?;
-    let rd_inc_stage5 = suffix_point(
-        store_point(store, symbols.inc_rd_stage5)?,
-        r_cycle_reduced.len(),
-        symbols.inc_rd_stage5,
-    )?;
-    let gamma = store_scalar(store, symbols.inc_gamma)?;
-    let eq_ram_combined = EqPolynomial::<Fr>::mle(ram_inc_stage2, &r_cycle_reduced)
-        + gamma * EqPolynomial::<Fr>::mle(ram_inc_stage4, &r_cycle_reduced);
-    let eq_rd_combined = EqPolynomial::<Fr>::mle(rd_inc_stage4, &r_cycle_reduced)
-        + gamma * EqPolynomial::<Fr>::mle(rd_inc_stage5, &r_cycle_reduced);
-    let ram_inc = eval_by_name(evals, symbols.inc_ram_eval)?;
-    let rd_inc = eval_by_name(evals, symbols.inc_rd_eval)?;
-    Ok(ram_inc * eq_ram_combined + gamma.square() * rd_inc * eq_rd_combined)
-}
-
-fn stage67_booleanity_evals(
-    evals: &[StageNamedEval<Fr>],
-    symbols: &Stage67RelationSymbols,
-) -> Result<Vec<Fr>, RuntimePlanError> {
-    let mut values = indexed_evals_by_prefix_any(evals, symbols.booleanity_instruction_ra_prefix)?;
-    values.extend(indexed_evals_by_prefix_any(
-        evals,
-        symbols.booleanity_bytecode_ra_prefix,
-    )?);
-    values.extend(indexed_evals_by_prefix_any(
-        evals,
-        symbols.booleanity_ram_ra_prefix,
-    )?);
-    Ok(values)
-}
-
-fn stage67_bytecode_stage_cycle_points(
-    store: &ValueStore<Fr>,
-    log_t: usize,
-    symbols: &Stage67BytecodeSymbols,
-) -> Result<[Vec<Fr>; 5], RuntimePlanError> {
-    let point = |index| {
-        let symbol = symbols.stage_cycle_points[index];
-        suffix_point(store_point(store, symbol)?, log_t, symbol).map(|point| point.to_vec())
-    };
-    Ok([point(0)?, point(1)?, point(2)?, point(3)?, point(4)?])
-}
-
-fn stage67_bytecode_stage_value_evals<E: Stage67BytecodeEntry>(
-    entries: &[E],
-    entry_bytecode_index: usize,
-    num_lookup_tables: usize,
-    store: &ValueStore<Fr>,
-    r_address: &[Fr],
-    log_t: usize,
-    symbols: &Stage67BytecodeSymbols,
-) -> Result<[Fr; 5], RuntimePlanError> {
-    let expected_len =
-        1usize
-            .checked_shl(r_address.len() as u32)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input: symbols.entries,
-                expected: usize::BITS as usize,
-                actual: r_address.len(),
-            })?;
-    if entries.len() != expected_len {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.entries,
-            expected: expected_len,
-            actual: entries.len(),
-        });
-    }
-    if entry_bytecode_index >= expected_len {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input: symbols.entry_bytecode_index,
-            expected: expected_len,
-            actual: entry_bytecode_index + 1,
-        });
-    }
-
-    let stage1_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[0])?, 16);
-    let stage2_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[1])?, 4);
-    let stage3_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[2])?, 9);
-    let stage4_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[3])?, 3);
-    let stage5_gamma_powers = field_powers(
-        store_scalar(store, symbols.stage_gammas[4])?,
-        num_lookup_tables + 2,
-    );
-
-    let stage4_register_point =
-        stage67_register_prefix_point(store, symbols.stage4_register_point, log_t)?;
-    let stage5_register_point =
-        stage67_register_prefix_point(store, symbols.stage5_register_point, log_t)?;
-
-    let mut evals = [Fr::from_u64(0); 5];
-    for (index, entry) in entries.iter().enumerate() {
-        let eq = indexed_boolean_eq(index, r_address);
-        let values = stage67_bytecode_entry_stage_values(
-            entry,
-            num_lookup_tables,
-            stage4_register_point,
-            stage5_register_point,
-            &stage1_gamma_powers,
-            &stage2_gamma_powers,
-            &stage3_gamma_powers,
-            &stage4_gamma_powers,
-            &stage5_gamma_powers,
-            symbols,
-        )?;
-        for stage in 0..evals.len() {
-            evals[stage] += eq * values[stage];
-        }
-    }
-    Ok(evals)
-}
-
-fn stage67_bytecode_entry_stage_values<E: Stage67BytecodeEntry>(
-    entry: &E,
-    num_lookup_tables: usize,
-    stage4_register_point: &[Fr],
-    stage5_register_point: &[Fr],
-    stage1_gamma_powers: &[Fr],
-    stage2_gamma_powers: &[Fr],
-    stage3_gamma_powers: &[Fr],
-    stage4_gamma_powers: &[Fr],
-    stage5_gamma_powers: &[Fr],
-    symbols: &Stage67BytecodeSymbols,
-) -> Result<[Fr; 5], RuntimePlanError> {
-    let flags = entry.circuit_flags();
-    let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1];
-    for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) {
-        if *flag {
-            stage1 += *gamma;
-        }
-    }
-
-    let mut stage2 = Fr::from_u64(0);
-    if flags[5] {
-        stage2 += stage2_gamma_powers[0];
-    }
-    if entry.is_branch() {
-        stage2 += stage2_gamma_powers[1];
-    }
-    if flags[6] {
-        stage2 += stage2_gamma_powers[2];
-    }
-    if flags[7] {
-        stage2 += stage2_gamma_powers[3];
-    }
-
-    let mut stage3 = entry.imm() + entry.address() * stage3_gamma_powers[1];
-    if entry.left_is_rs1() {
-        stage3 += stage3_gamma_powers[2];
-    }
-    if entry.left_is_pc() {
-        stage3 += stage3_gamma_powers[3];
-    }
-    if entry.right_is_rs2() {
-        stage3 += stage3_gamma_powers[4];
-    }
-    if entry.right_is_imm() {
-        stage3 += stage3_gamma_powers[5];
-    }
-    if entry.is_noop() {
-        stage3 += stage3_gamma_powers[6];
-    }
-    if flags[7] {
-        stage3 += stage3_gamma_powers[7];
-    }
-    if flags[12] {
-        stage3 += stage3_gamma_powers[8];
-    }
-
-    let stage4 = stage67_register_eq(entry.rd(), stage4_register_point, symbols.entry_rd)?
-        * stage4_gamma_powers[0]
-        + stage67_register_eq(entry.rs1(), stage4_register_point, symbols.entry_rs1)?
-            * stage4_gamma_powers[1]
-        + stage67_register_eq(entry.rs2(), stage4_register_point, symbols.entry_rs2)?
-            * stage4_gamma_powers[2];
-
-    let mut stage5 = stage67_register_eq(entry.rd(), stage5_register_point, symbols.entry_rd)?
-        * stage5_gamma_powers[0];
-    if !entry.is_interleaved() {
-        stage5 += stage5_gamma_powers[1];
-    }
-    if let Some(table) = entry.lookup_table() {
-        if table >= num_lookup_tables {
-            return Err(RuntimePlanError::InvalidInputLength {
-                input: symbols.entry_lookup_table,
-                expected: num_lookup_tables,
-                actual: table + 1,
-            });
-        }
-        stage5 += stage5_gamma_powers[2 + table];
-    }
-
-    Ok([stage1, stage2, stage3, stage4, stage5])
-}
-
-fn stage67_register_eq(
-    index: Option<usize>,
-    point: &[Fr],
-    input: &'static str,
-) -> Result<Fr, RuntimePlanError> {
-    let Some(index) = index else {
-        return Ok(Fr::from_u64(0));
-    };
-    let register_count =
-        1usize
-            .checked_shl(point.len() as u32)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input,
-                expected: usize::BITS as usize,
-                actual: point.len(),
-            })?;
-    if index >= register_count {
-        return Err(RuntimePlanError::InvalidInputLength {
-            input,
-            expected: register_count,
-            actual: index + 1,
-        });
-    }
-    Ok(indexed_boolean_eq(index, point))
-}
-
-fn stage67_register_prefix_point<'a>(
-    store: &'a ValueStore<Fr>,
-    symbol: &'static str,
-    log_t: usize,
-) -> Result<&'a [Fr], RuntimePlanError> {
-    let point = store_point(store, symbol)?;
-    let register_len =
-        point
-            .len()
-            .checked_sub(log_t)
-            .ok_or(RuntimePlanError::InvalidInputLength {
-                input: symbol,
-                expected: log_t,
-                actual: point.len(),
-            })?;
-    prefix_point(point, register_len, symbol)
-}
-
-pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Fr {
-    let stride_offset = usize::from(!left);
-    let operand_bits = point.len() / 2;
-    (0..operand_bits)
-        .map(|index| point[2 * index + stride_offset].mul_pow_2(operand_bits - 1 - index))
-        .sum()
-}
-
-pub fn identity_polynomial_eval(point: &[Fr]) -> Fr {
-    point
-        .iter()
-        .enumerate()
-        .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index))
-        .sum()
-}
-
-pub fn append_labeled_scalar<T>(transcript: &mut T, label: &'static str, scalar: &Fr)
-where
-    T: Transcript<Challenge = Fr>,
-{
-    transcript.append(&Label(label.as_bytes()));
-    transcript.append(scalar);
-}
-
-pub fn append_opening_claims<T, E>(
-    opening_inputs: &[OpeningInputPlan],
-    opening_claims: &[OpeningClaimPlan],
-    opening_batches: &[OpeningBatchPlan],
-    store: &mut ValueStore<Fr>,
-    transcript: &mut T,
-    evals: &[StageNamedEval<Fr>],
-    missing_claim: impl Fn(&'static str, &'static str) -> E,
-    missing_value: impl Fn(&'static str) -> E,
-) -> Result<(), E>
-where
-    T: Transcript<Challenge = Fr>,
-{
-    if opening_batches.is_empty() {
-        for eval in evals {
-            append_labeled_scalar(transcript, "opening_claim", &eval.value);
-        }
-        return Ok(());
-    }
-    let mut seen = opening_inputs
-        .iter()
-        .filter_map(|input| {
-            store
-                .try_point(input.symbol)
-                .map(|point| (input.claim_kind, input.oracle, point.to_vec()))
-        })
-        .collect::<Vec<_>>();
-    for batch in opening_batches {
-        for symbol in symbol_list(batch.claim_operands) {
-            let claim = opening_claims
-                .iter()
-                .find(|claim| claim.symbol == symbol)
-                .ok_or_else(|| missing_claim(batch.symbol, symbol))?;
-            let point = store.point_or(claim.point_source, &missing_value)?.to_vec();
-            if seen.iter().any(|(kind, oracle, seen_point)| {
-                *kind == claim.claim_kind && *oracle == claim.oracle && seen_point == &point
-            }) {
-                continue;
-            }
-            let value = store.scalar_or(claim.eval_source, &missing_value)?;
-            append_labeled_scalar(transcript, "opening_claim", &value);
-            seen.push((claim.claim_kind, claim.oracle, point));
-        }
-    }
-    Ok(())
-}
-
-pub fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Fr {
-    let mut lt_eval = Fr::from_u64(0);
-    let mut eq_term = Fr::from_u64(1);
-    for (x_i, y_i) in x.iter().zip(y.iter()) {
-        lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term;
-        eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i;
-    }
-    lt_eval
-}
-
-pub fn pow_field<F: Field>(base: F, mut exponent: usize) -> F {
-    let mut result = F::one();
-    let mut power = base;
-    while exponent != 0 {
-        if exponent & 1 == 1 {
-            result *= power;
-        }
-        power = power.square();
-        exponent >>= 1;
-    }
-    result
-}
-
-pub fn reverse_slice(values: &[Fr]) -> Vec<Fr> {
-    values.iter().rev().copied().collect()
-}
diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs
new file mode 100644
index 0000000000..4615299bfe
--- /dev/null
+++ b/crates/jolt-verifier/src/stages/jolt_relations.rs
@@ -0,0 +1,696 @@
+#![expect(
+    clippy::too_many_arguments,
+    reason = "Stage 6/7 verifier relation helpers thread typed plan symbols and store/eval slices through their argument lists"
+)]
+
+//! Tier B: Audited Jolt verifier core.
+//!
+//! This module is **not** generic Bolt scaffolding. It is the hand-written
+//! Jolt-specific verifier math that the Bolt compiler does not yet lower
+//! from MLIR. It includes:
+//!
+//! - point normalizations for the Jolt bytecode and instruction RA
+//!   read-RAF lookup arguments
+//! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement
+//! - typed bytecode read-RAF plan data and its small Jolt-specific evaluator
+//! - the small Jolt-specific field-math helpers
+//!   (`operand_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt
+//!   verification
+//!
+//! Treat changes here as Jolt protocol changes, not as compiler-output
+//! cleanups. Generic Bolt verifier scaffolding (typed plan structs,
+//! `ValueStore`, generic sumcheck verification, generic field-expr
+//! dispatch) lives in `bolt_verifier_runtime` instead.
+//!
+//! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition.
+
+use jolt_field::{Field, Fr};
+use jolt_lookup_tables::LookupTableKind;
+use jolt_poly::{EqPolynomial, IdentityPolynomial};
+
+use bolt_verifier_runtime::{
+    field_powers, prefix_point, store_point, store_scalar, suffix_point, NamedEvalFamilyPlan,
+    NamedScalar, RuntimePlanError, SumcheckInstanceResultPlan, ValueStore,
+};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[rustfmt::skip]
+pub enum JoltRelationKind { Stage1OuterUniskip, Stage1OuterRemaining, Stage2ProductVirtualUniskip, Stage2RamReadWrite, Stage2ProductVirtualRemainder, Stage2InstructionLookupClaimReduction, Stage2RamRafEvaluation, Stage2RamOutputCheck, Stage2Batched, Stage3SpartanShift, Stage3InstructionInput, Stage3RegistersClaimReduction, Stage3Batched, Stage4RegistersReadWrite, Stage4RamValCheck, Stage4Batched, Stage5InstructionReadRaf, Stage5RamRaClaimReduction, Stage5RegistersValEvaluation, Stage5Batched, Stage6BytecodeReadRaf, Stage6Booleanity, Stage6HammingBooleanity, Stage6RamRaVirtual, Stage6InstructionRaVirtual, Stage6IncClaimReduction, Stage6Batched, Stage7HammingWeightClaimReduction, Stage7Batched }
+
+pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] {
+    let mut powers = [Fr::from_u64(1); 8];
+    for index in 1..powers.len() {
+        powers[index] = powers[index - 1] * gamma;
+    }
+    powers
+}
+
+pub fn normalize_bytecode_read_raf_point<F: Field>(
+    point: &[F],
+    log_t: usize,
+    input: &'static str,
+) -> Result<Vec<F>, RuntimePlanError> {
+    let log_k = point
+        .len()
+        .checked_sub(log_t)
+        .ok_or(RuntimePlanError::InvalidInputLength {
+            input,
+            expected: log_t,
+            actual: point.len(),
+        })?;
+    let mut normalized = point.to_vec();
+    normalized[..log_k].reverse();
+    normalized[log_k..].reverse();
+    Ok(normalized)
+}
+
+pub fn normalize_instruction_read_raf_point<F: Field>(
+    point: &[F],
+    input: &'static str,
+) -> Result<Vec<F>, RuntimePlanError> {
+    const LOG_K: usize = 128;
+    if point.len() < LOG_K {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input,
+            expected: LOG_K,
+            actual: point.len(),
+        });
+    }
+    let mut normalized = point.to_vec();
+    normalized[LOG_K..].reverse();
+    Ok(normalized)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage67RelationSymbols {
+    pub hamming_booleanity_instance: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage5InstructionReadRafPlan {
+    pub point: &'static str,
+    pub lookup_output_point: &'static str,
+    pub table_flag_evals: &'static NamedEvalFamilyPlan,
+    pub instruction_ra_evals: &'static NamedEvalFamilyPlan,
+    pub raf_flag_eval: &'static str,
+    pub gamma: &'static str,
+    pub local_scalars: &'static [JoltLocalScalarPlan],
+    pub log_k: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct JoltLocalScalarPlan {
+    pub symbol: &'static str,
+    pub kind: JoltLocalScalarMleKind,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum JoltLocalScalarMleKind {
+    LookupTable { index: usize },
+    LeftOperand,
+    RightOperand,
+    Identity,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage67BytecodeReadRafPlan {
+    pub point: &'static str,
+    pub gamma: &'static str,
+    pub bytecode_ra_evals: &'static NamedEvalFamilyPlan,
+    pub entries: &'static str,
+    pub entry_bytecode_index: &'static str,
+    pub stages: &'static [Stage67BytecodeStagePlan],
+    pub output_terms: &'static [Stage67BytecodeOutputTermPlan],
+    pub output_contribution: &'static str,
+    pub registers: Stage67BytecodeRegisterSymbols,
+    pub entry_lookup_table: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage67BytecodeStagePlan {
+    pub gamma: &'static str,
+    pub cycle_point: &'static str,
+    pub register_point: Option<&'static str>,
+    pub terms: &'static [Stage67BytecodeTermPlan],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage67BytecodeOutputTermPlan {
+    StageValue {
+        symbol: &'static str,
+        stage_index: usize,
+        gamma_power: usize,
+        identity_gamma_power: Option<usize>,
+    },
+    Entry {
+        symbol: &'static str,
+        gamma_power: usize,
+    },
+}
+
+impl Stage67BytecodeOutputTermPlan {
+    fn symbol(self) -> &'static str {
+        match self {
+            Self::StageValue { symbol, .. } | Self::Entry { symbol, .. } => symbol,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage67BytecodeRegisterSymbols {
+    pub rd: &'static str,
+    pub rs1: &'static str,
+    pub rs2: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage67BytecodeTermPlan {
+    Address {
+        gamma_power: usize,
+    },
+    Imm {
+        gamma_power: usize,
+    },
+    CircuitFlag {
+        index: usize,
+        gamma_power: usize,
+    },
+    EntryFlag {
+        flag: Stage67BytecodeFlag,
+        expected: bool,
+        gamma_power: usize,
+    },
+    RegisterEq {
+        register: Stage67BytecodeRegister,
+        gamma_power: usize,
+    },
+    LookupTable {
+        gamma_base: usize,
+    },
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage67BytecodeFlag {
+    IsInterleaved,
+    IsBranch,
+    LeftIsRs1,
+    LeftIsPc,
+    RightIsRs2,
+    RightIsImm,
+    IsNoop,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage67BytecodeRegister {
+    Rd,
+    Rs1,
+    Rs2,
+}
+
+pub trait Stage67BytecodeEntry {
+    fn address(&self) -> Fr;
+    fn imm(&self) -> Fr;
+    fn circuit_flags(&self) -> &[bool; 14];
+    fn rd(&self) -> Option<usize>;
+    fn rs1(&self) -> Option<usize>;
+    fn rs2(&self) -> Option<usize>;
+    fn lookup_table(&self) -> Option<usize>;
+    fn is_interleaved(&self) -> bool;
+    fn is_branch(&self) -> bool;
+    fn left_is_rs1(&self) -> bool;
+    fn left_is_pc(&self) -> bool;
+    fn right_is_rs2(&self) -> bool;
+    fn right_is_imm(&self) -> bool;
+    fn is_noop(&self) -> bool;
+}
+
+pub fn evaluate_stage5_instruction_read_raf_local_scalars(
+    plan: &Stage5InstructionReadRafPlan,
+    local_point: &[Fr],
+) -> Result<Vec<NamedScalar<Fr>>, RuntimePlanError> {
+    let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?;
+    evaluate_jolt_local_scalars(plan.local_scalars, r_address_prime)
+}
+
+pub fn evaluate_jolt_local_scalars(
+    plans: &[JoltLocalScalarPlan],
+    point: &[Fr],
+) -> Result<Vec<NamedScalar<Fr>>, RuntimePlanError> {
+    let mut scalars = Vec::with_capacity(plans.len());
+    for value in plans {
+        let scalar = evaluate_jolt_local_scalar(value.kind, point)?;
+        scalars.push(NamedScalar {
+            symbol: value.symbol,
+            value: scalar,
+        });
+    }
+    Ok(scalars)
+}
+
+fn evaluate_jolt_local_scalar(
+    kind: JoltLocalScalarMleKind,
+    point: &[Fr],
+) -> Result<Fr, RuntimePlanError> {
+    const XLEN: usize = 64;
+    Ok(match kind {
+        JoltLocalScalarMleKind::LookupTable { index } => {
+            let tables = LookupTableKind::<XLEN>::all();
+            let table = tables
+                .get(index)
+                .ok_or(RuntimePlanError::InvalidInputLength {
+                    input: "stage5.instruction_read_raf.lookup_table",
+                    expected: tables.len(),
+                    actual: index + 1,
+                })?;
+            table.evaluate_mle::<Fr, Fr>(point)
+        }
+        JoltLocalScalarMleKind::LeftOperand => operand_polynomial_eval(point, true)?,
+        JoltLocalScalarMleKind::RightOperand => operand_polynomial_eval(point, false)?,
+        JoltLocalScalarMleKind::Identity => IdentityPolynomial::new(point.len()).evaluate(point),
+    })
+}
+
+fn instruction_read_raf_point_parts<'a>(
+    plan: &Stage5InstructionReadRafPlan,
+    local_point: &'a [Fr],
+) -> Result<(&'a [Fr], &'a [Fr]), RuntimePlanError> {
+    if local_point.len() < plan.log_k {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input: plan.point,
+            expected: plan.log_k,
+            actual: local_point.len(),
+        });
+    }
+    Ok(local_point.split_at(plan.log_k))
+}
+
+pub fn stage67_trace_rounds(
+    instance_results: &[SumcheckInstanceResultPlan<JoltRelationKind>],
+    symbols: &Stage67RelationSymbols,
+) -> Result<usize, RuntimePlanError> {
+    instance_results
+        .iter()
+        .find(|instance| instance.relation == JoltRelationKind::Stage6HammingBooleanity)
+        .map(|instance| instance.num_rounds)
+        .ok_or(RuntimePlanError::MissingValue {
+            symbol: symbols.hamming_booleanity_instance,
+        })
+}
+
+pub fn evaluate_stage67_bytecode_read_raf_output_scalars<E: Stage67BytecodeEntry>(
+    plan: &Stage67BytecodeReadRafPlan,
+    entries: &[E],
+    entry_bytecode_index: usize,
+    num_lookup_tables: usize,
+    store: &ValueStore<Fr>,
+    local_point: &[Fr],
+    log_t: usize,
+) -> Result<Vec<NamedScalar<Fr>>, RuntimePlanError> {
+    let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, plan.point)?;
+    let log_k = opening_point.len() - log_t;
+    let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k);
+
+    let gamma = store_scalar(store, plan.gamma)?;
+    let gamma_powers = bytecode_gamma_powers(gamma);
+    let stage_value_evals = stage67_bytecode_stage_value_evals(
+        plan,
+        entries,
+        entry_bytecode_index,
+        num_lookup_tables,
+        store,
+        r_address_prime,
+        r_cycle_prime.len(),
+    )?;
+    stage67_bytecode_output_terms(
+        plan,
+        store,
+        &stage_value_evals,
+        &gamma_powers,
+        entry_bytecode_index,
+        r_address_prime,
+        r_cycle_prime,
+        log_k,
+    )
+}
+
+fn stage67_bytecode_output_terms(
+    plan: &Stage67BytecodeReadRafPlan,
+    store: &ValueStore<Fr>,
+    stage_value_evals: &[Fr],
+    gamma_powers: &[Fr],
+    entry_bytecode_index: usize,
+    r_address_prime: &[Fr],
+    r_cycle_prime: &[Fr],
+    log_k: usize,
+) -> Result<Vec<NamedScalar<Fr>>, RuntimePlanError> {
+    let int_eval = IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime);
+    let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()];
+    let entry_address_eq =
+        EqPolynomial::<Fr>::try_mle_at_boolean_index(entry_bytecode_index, r_address_prime).ok_or(
+            RuntimePlanError::InvalidInputLength {
+                input: plan.entry_bytecode_index,
+                expected: 1usize.checked_shl(log_k as u32).unwrap_or(usize::MAX),
+                actual: entry_bytecode_index.saturating_add(1),
+            },
+        )?;
+
+    let mut output_terms = Vec::with_capacity(plan.output_terms.len());
+    for term in plan.output_terms {
+        let value = match *term {
+            Stage67BytecodeOutputTermPlan::StageValue {
+                symbol: _,
+                stage_index,
+                gamma_power,
+                identity_gamma_power,
+            } => {
+                let stage =
+                    plan.stages
+                        .get(stage_index)
+                        .ok_or(RuntimePlanError::InvalidInputLength {
+                            input: plan.entries,
+                            expected: stage_index + 1,
+                            actual: plan.stages.len(),
+                        })?;
+                let value = stage_value_evals.get(stage_index).copied().ok_or(
+                    RuntimePlanError::InvalidInputLength {
+                        input: plan.entries,
+                        expected: stage_index + 1,
+                        actual: stage_value_evals.len(),
+                    },
+                )?;
+                let cycle_point =
+                    stage67_bytecode_stage_cycle_point(store, stage, r_cycle_prime.len())?;
+                let identity_contrib = identity_gamma_power
+                    .map_or(Fr::from_u64(0), |power| gamma_powers[power] * int_eval);
+                (value + identity_contrib)
+                    * EqPolynomial::<Fr>::mle(&cycle_point, r_cycle_prime)
+                    * gamma_powers[gamma_power]
+            }
+            Stage67BytecodeOutputTermPlan::Entry {
+                symbol: _,
+                gamma_power,
+            } => {
+                gamma_powers[gamma_power]
+                    * entry_address_eq
+                    * EqPolynomial::<Fr>::mle(&zero_cycle, r_cycle_prime)
+            }
+        };
+        output_terms.push(NamedScalar {
+            symbol: (*term).symbol(),
+            value,
+        });
+    }
+    Ok(output_terms)
+}
+
+fn stage67_bytecode_stage_cycle_point(
+    store: &ValueStore<Fr>,
+    stage: &Stage67BytecodeStagePlan,
+    log_t: usize,
+) -> Result<Vec<Fr>, RuntimePlanError> {
+    suffix_point(
+        store_point(store, stage.cycle_point)?,
+        log_t,
+        stage.cycle_point,
+    )
+    .map(|point| point.to_vec())
+}
+
+fn stage67_bytecode_stage_value_evals<E: Stage67BytecodeEntry>(
+    plan: &Stage67BytecodeReadRafPlan,
+    entries: &[E],
+    entry_bytecode_index: usize,
+    num_lookup_tables: usize,
+    store: &ValueStore<Fr>,
+    r_address: &[Fr],
+    log_t: usize,
+) -> Result<Vec<Fr>, RuntimePlanError> {
+    let expected_len =
+        1usize
+            .checked_shl(r_address.len() as u32)
+            .ok_or(RuntimePlanError::InvalidInputLength {
+                input: plan.entries,
+                expected: usize::BITS as usize,
+                actual: r_address.len(),
+            })?;
+    if entries.len() != expected_len {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input: plan.entries,
+            expected: expected_len,
+            actual: entries.len(),
+        });
+    }
+    if entry_bytecode_index >= expected_len {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input: plan.entry_bytecode_index,
+            expected: expected_len,
+            actual: entry_bytecode_index + 1,
+        });
+    }
+
+    let stage_contexts = plan
+        .stages
+        .iter()
+        .map(|stage| {
+            Ok(Stage67BytecodeStageContext {
+                plan: stage,
+                gamma_powers: field_powers(
+                    store_scalar(store, stage.gamma)?,
+                    stage67_bytecode_stage_gamma_power_count(stage, num_lookup_tables),
+                ),
+                register_point: match stage.register_point {
+                    Some(symbol) => Some(stage67_register_prefix_point(store, symbol, log_t)?),
+                    None => None,
+                },
+            })
+        })
+        .collect::<Result<Vec<_>, RuntimePlanError>>()?;
+
+    let mut evals = vec![Fr::from_u64(0); plan.stages.len()];
+    for (index, entry) in entries.iter().enumerate() {
+        let eq = EqPolynomial::<Fr>::try_mle_at_boolean_index(index, r_address).ok_or(
+            RuntimePlanError::InvalidInputLength {
+                input: plan.entries,
+                expected: expected_len,
+                actual: index + 1,
+            },
+        )?;
+        let values = stage67_bytecode_entry_stage_values(plan, entry, &stage_contexts)?;
+        for stage in 0..evals.len() {
+            evals[stage] += eq * values[stage];
+        }
+    }
+    Ok(evals)
+}
+
+struct Stage67BytecodeStageContext<'a> {
+    plan: &'a Stage67BytecodeStagePlan,
+    gamma_powers: Vec<Fr>,
+    register_point: Option<&'a [Fr]>,
+}
+
+fn stage67_bytecode_entry_stage_values<E: Stage67BytecodeEntry>(
+    plan: &Stage67BytecodeReadRafPlan,
+    entry: &E,
+    stage_contexts: &[Stage67BytecodeStageContext<'_>],
+) -> Result<Vec<Fr>, RuntimePlanError> {
+    stage_contexts
+        .iter()
+        .map(|context| stage67_bytecode_entry_stage_value(plan, entry, context))
+        .collect()
+}
+
+fn stage67_bytecode_entry_stage_value<E: Stage67BytecodeEntry>(
+    plan: &Stage67BytecodeReadRafPlan,
+    entry: &E,
+    context: &Stage67BytecodeStageContext<'_>,
+) -> Result<Fr, RuntimePlanError> {
+    let mut value = Fr::from_u64(0);
+    for term in context.plan.terms {
+        value += match *term {
+            Stage67BytecodeTermPlan::Address { gamma_power } => {
+                entry.address() * context.gamma_powers[gamma_power]
+            }
+            Stage67BytecodeTermPlan::Imm { gamma_power } => {
+                entry.imm() * context.gamma_powers[gamma_power]
+            }
+            Stage67BytecodeTermPlan::CircuitFlag { index, gamma_power } => {
+                if entry.circuit_flags()[index] {
+                    context.gamma_powers[gamma_power]
+                } else {
+                    Fr::from_u64(0)
+                }
+            }
+            Stage67BytecodeTermPlan::EntryFlag {
+                flag,
+                expected,
+                gamma_power,
+            } => {
+                if stage67_bytecode_entry_flag(entry, flag) == expected {
+                    context.gamma_powers[gamma_power]
+                } else {
+                    Fr::from_u64(0)
+                }
+            }
+            Stage67BytecodeTermPlan::RegisterEq {
+                register,
+                gamma_power,
+            } => {
+                let register_point =
+                    context
+                        .register_point
+                        .ok_or(RuntimePlanError::MissingValue {
+                            symbol: context.plan.cycle_point,
+                        })?;
+                stage67_register_eq(
+                    stage67_bytecode_entry_register(entry, register),
+                    register_point,
+                    stage67_bytecode_register_symbol(plan, register),
+                )? * context.gamma_powers[gamma_power]
+            }
+            Stage67BytecodeTermPlan::LookupTable { gamma_base } => {
+                let Some(table) = entry.lookup_table() else {
+                    continue;
+                };
+                if table >= plan_lookup_table_count(context, gamma_base) {
+                    return Err(RuntimePlanError::InvalidInputLength {
+                        input: plan.entry_lookup_table,
+                        expected: plan_lookup_table_count(context, gamma_base),
+                        actual: table + 1,
+                    });
+                }
+                context.gamma_powers[gamma_base + table]
+            }
+        };
+    }
+    Ok(value)
+}
+
+fn stage67_bytecode_stage_gamma_power_count(
+    stage: &Stage67BytecodeStagePlan,
+    num_lookup_tables: usize,
+) -> usize {
+    stage
+        .terms
+        .iter()
+        .map(|term| match *term {
+            Stage67BytecodeTermPlan::Address { gamma_power }
+            | Stage67BytecodeTermPlan::Imm { gamma_power }
+            | Stage67BytecodeTermPlan::CircuitFlag { gamma_power, .. }
+            | Stage67BytecodeTermPlan::EntryFlag { gamma_power, .. }
+            | Stage67BytecodeTermPlan::RegisterEq { gamma_power, .. } => gamma_power + 1,
+            Stage67BytecodeTermPlan::LookupTable { gamma_base } => gamma_base + num_lookup_tables,
+        })
+        .max()
+        .unwrap_or(0)
+}
+
+fn plan_lookup_table_count(context: &Stage67BytecodeStageContext<'_>, gamma_base: usize) -> usize {
+    context.gamma_powers.len().saturating_sub(gamma_base)
+}
+
+fn stage67_bytecode_entry_flag<E: Stage67BytecodeEntry>(
+    entry: &E,
+    flag: Stage67BytecodeFlag,
+) -> bool {
+    match flag {
+        Stage67BytecodeFlag::IsInterleaved => entry.is_interleaved(),
+        Stage67BytecodeFlag::IsBranch => entry.is_branch(),
+        Stage67BytecodeFlag::LeftIsRs1 => entry.left_is_rs1(),
+        Stage67BytecodeFlag::LeftIsPc => entry.left_is_pc(),
+        Stage67BytecodeFlag::RightIsRs2 => entry.right_is_rs2(),
+        Stage67BytecodeFlag::RightIsImm => entry.right_is_imm(),
+        Stage67BytecodeFlag::IsNoop => entry.is_noop(),
+    }
+}
+
+fn stage67_bytecode_entry_register<E: Stage67BytecodeEntry>(
+    entry: &E,
+    register: Stage67BytecodeRegister,
+) -> Option<usize> {
+    match register {
+        Stage67BytecodeRegister::Rd => entry.rd(),
+        Stage67BytecodeRegister::Rs1 => entry.rs1(),
+        Stage67BytecodeRegister::Rs2 => entry.rs2(),
+    }
+}
+
+fn stage67_bytecode_register_symbol(
+    plan: &Stage67BytecodeReadRafPlan,
+    register: Stage67BytecodeRegister,
+) -> &'static str {
+    match register {
+        Stage67BytecodeRegister::Rd => plan.registers.rd,
+        Stage67BytecodeRegister::Rs1 => plan.registers.rs1,
+        Stage67BytecodeRegister::Rs2 => plan.registers.rs2,
+    }
+}
+
+fn stage67_register_eq(
+    index: Option<usize>,
+    point: &[Fr],
+    input: &'static str,
+) -> Result<Fr, RuntimePlanError> {
+    let Some(index) = index else {
+        return Ok(Fr::from_u64(0));
+    };
+    let register_count =
+        1usize
+            .checked_shl(point.len() as u32)
+            .ok_or(RuntimePlanError::InvalidInputLength {
+                input,
+                expected: usize::BITS as usize,
+                actual: point.len(),
+            })?;
+    if index >= register_count {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input,
+            expected: register_count,
+            actual: index + 1,
+        });
+    }
+    EqPolynomial::<Fr>::try_mle_at_boolean_index(index, point).ok_or(
+        RuntimePlanError::InvalidInputLength {
+            input,
+            expected: register_count,
+            actual: index + 1,
+        },
+    )
+}
+
+fn stage67_register_prefix_point<'a>(
+    store: &'a ValueStore<Fr>,
+    symbol: &'static str,
+    log_t: usize,
+) -> Result<&'a [Fr], RuntimePlanError> {
+    let point = store_point(store, symbol)?;
+    let register_len =
+        point
+            .len()
+            .checked_sub(log_t)
+            .ok_or(RuntimePlanError::InvalidInputLength {
+                input: symbol,
+                expected: log_t,
+                actual: point.len(),
+            })?;
+    prefix_point(point, register_len, symbol)
+}
+
+pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Result<Fr, RuntimePlanError> {
+    let stride_offset = usize::from(!left);
+    let operand_bits = point.len() / 2;
+    if point.len() != operand_bits * 2 {
+        return Err(RuntimePlanError::InvalidInputLength {
+            input: "stage5.instruction_read_raf.operand_point",
+            expected: operand_bits * 2,
+            actual: point.len(),
+        });
+    }
+    IdentityPolynomial::new(operand_bits)
+        .try_evaluate_projected(point, stride_offset, 2)
+        .ok_or(RuntimePlanError::InvalidInputLength {
+            input: "stage5.instruction_read_raf.operand_point",
+            expected: operand_bits * 2,
+            actual: point.len(),
+        })
+}
diff --git a/crates/jolt-verifier/src/stages/mod.rs b/crates/jolt-verifier/src/stages/mod.rs
index 14f741edaa..c29b7b6bfc 100644
--- a/crates/jolt-verifier/src/stages/mod.rs
+++ b/crates/jolt-verifier/src/stages/mod.rs
@@ -1,4 +1,4 @@
-pub mod common;
+pub mod jolt_relations;
 #[rustfmt::skip]
 pub mod commitment;
 #[rustfmt::skip]
diff --git a/crates/jolt-verifier/src/stages/stage1_outer.rs b/crates/jolt-verifier/src/stages/stage1_outer.rs
index 8d08183783..95e1f4dae2 100644
--- a/crates/jolt-verifier/src/stages/stage1_outer.rs
+++ b/crates/jolt-verifier/src/stages/stage1_outer.rs
@@ -1,27 +1,30 @@
 #![allow(dead_code)]
 
-use super::common::append_labeled_scalar;
+use bolt_verifier_runtime::append_labeled_scalar;
 use jolt_field::Fr;
 use jolt_sumcheck::{CompressedLabeledRoundPoly, LabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier};
 use jolt_transcript::{Blake2bTranscript, Transcript};
 
 pub type DefaultStage1Transcript = Blake2bTranscript<Fr>;
 
-pub type Stage1Params = super::common::StageParams;
-pub type Stage1NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage1SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage1ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage1ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage1Proof<F> = super::common::StageProof<F>;
-pub type Stage1VerifierProgramPlan = super::common::VerifierProgramPlanMinimal;
+pub type Stage1Params = bolt_verifier_runtime::StageParams;
+pub type Stage1NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage1SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage1ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage1ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage1Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage1VerifierProgramPlan = bolt_verifier_runtime::VerifierProgramPlanMinimal<Stage1RelationKind>;
+pub type Stage1SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage1RelationKind>;
+pub type Stage1SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage1RelationKind>;
+pub type Stage1SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage1RelationKind>;
 
-pub use super::common::{
-    OpeningBatchPlan as Stage1OpeningBatchPlan, OpeningClaimPlan as Stage1OpeningClaimPlan,
+pub use super::jolt_relations::JoltRelationKind as Stage1RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage1ClaimKind, OpeningBatchPlan as Stage1OpeningBatchPlan,
+    OpeningClaimPlan as Stage1OpeningClaimPlan,
     SumcheckBatchPlan as Stage1SumcheckBatchPlan, SumcheckEvalPlan as Stage1SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage1SumcheckInstanceResultPlan,
+    TranscriptSqueezeKind as Stage1TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage1TranscriptSqueezePlan,
-    SumcheckClaimPlan as Stage1SumcheckClaimPlan,
-    SumcheckDriverPlan as Stage1SumcheckDriverPlan,
 };
 
 #[derive(Debug)]
@@ -32,50 +35,38 @@ pub enum VerifyStage1Error {
     MissingClaim { driver: &'static str, claim: &'static str },
     MissingDependency { driver: &'static str, dependency: &'static str },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage1RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-pub const STAGE1_PARAMS: Stage1Params = Stage1Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE1_PARAMS: Stage1Params = Stage1Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE1_TRANSCRIPT_SQUEEZES: &[Stage1TranscriptSqueezePlan] = &[
-    Stage1TranscriptSqueezePlan { symbol: "stage1.tau", label: "outer_tau", kind: "challenge_vector", count: 18 },
+    Stage1TranscriptSqueezePlan { symbol: "stage1.tau", label: "outer_tau", kind: Stage1TranscriptSqueezeKind::ChallengeVector, count: 18 },
 ];
 
 pub const STAGE1_SUMCHECK_CLAIMS: &[Stage1SumcheckClaimPlan] = &[
-    Stage1SumcheckClaimPlan { symbol: "stage1.uniskip.input", stage: "stage1", domain: "jolt.stage1_uniskip_domain", num_rounds: 1, degree: 27, claim: "stage1.zero", kernel: None, relation: Some("jolt.stage1.outer.uniskip"), claim_value: "stage1.zero", input_openings: "" },
-    Stage1SumcheckClaimPlan { symbol: "stage1.outer_remaining.input", stage: "stage1", domain: "jolt.trace_domain", num_rounds: 17, degree: 3, claim: "stage1.uniskip.eval", kernel: None, relation: Some("jolt.stage1.outer.remaining"), claim_value: "stage1.uniskip.eval", input_openings: "stage1.uniskip.opening" },
-];
-pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    1,
+    Stage1SumcheckClaimPlan { symbol: "stage1.uniskip.input", stage: "stage1", domain: "jolt.stage1_uniskip_domain", num_rounds: 1, degree: 27, claim: "stage1.zero", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterUniskip), claim_value: "stage1.zero" },
+    Stage1SumcheckClaimPlan { symbol: "stage1.outer_remaining.input", stage: "stage1", domain: "jolt.trace_domain", num_rounds: 17, degree: 3, claim: "stage1.uniskip.eval", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterRemaining), claim_value: "stage1.uniskip.eval" },
 ];
+pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1];
 
-pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[
-    17,
-];
+pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[17];
 
 pub const STAGE1_SUMCHECK_BATCHES: &[Stage1SumcheckBatchPlan] = &[
-    Stage1SumcheckBatchPlan { symbol: "stage1.uniskip.batch", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: "stage1.uniskip.input", claim_operands: "stage1.uniskip.input", claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
-    Stage1SumcheckBatchPlan { symbol: "stage1.outer_remaining.batch", stage: "stage1", proof_slot: "stage1.sumcheck", policy: "jolt_core_front_loaded", count: 1, ordered_claims: "stage1.outer_remaining.input", claim_operands: "stage1.outer_remaining.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE },
-];
-pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    1,
+    Stage1SumcheckBatchPlan { symbol: "stage1.uniskip.batch", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", policy: "single_instance", count: 1, claim_operands: &["stage1.uniskip.input"], claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
+    Stage1SumcheckBatchPlan { symbol: "stage1.outer_remaining.batch", stage: "stage1", proof_slot: "stage1.sumcheck", policy: "jolt_core_front_loaded", count: 1, claim_operands: &["stage1.outer_remaining.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE },
 ];
+pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1];
 
-pub const STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[
-    17,
-];
+pub const STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[17];
 
 pub const STAGE1_SUMCHECK_DRIVERS: &[Stage1SumcheckDriverPlan] = &[
-    Stage1SumcheckDriverPlan { symbol: "stage1.uniskip.sumcheck", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", kernel: None, relation: Some("jolt.stage1.outer.uniskip"), batch: "stage1.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 27 },
-    Stage1SumcheckDriverPlan { symbol: "stage1.outer_remaining.sumcheck", stage: "stage1", proof_slot: "stage1.sumcheck", kernel: None, relation: Some("jolt.stage1.outer.remaining"), batch: "stage1.outer_remaining.batch", policy: "jolt_core_front_loaded", round_schedule: STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 17, degree: 3 },
+    Stage1SumcheckDriverPlan { symbol: "stage1.uniskip.sumcheck", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterUniskip), batch: "stage1.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 27 },
+    Stage1SumcheckDriverPlan { symbol: "stage1.outer_remaining.sumcheck", stage: "stage1", proof_slot: "stage1.sumcheck", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterRemaining), batch: "stage1.outer_remaining.batch", policy: "jolt_core_front_loaded", round_schedule: STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 17, degree: 3 },
 ];
 pub const STAGE1_SUMCHECK_INSTANCE_RESULTS: &[Stage1SumcheckInstanceResultPlan] = &[
-    Stage1SumcheckInstanceResultPlan { symbol: "stage1.uniskip.instance", source: "stage1.uniskip.sumcheck", claim: "stage1.uniskip.input", relation: "jolt.stage1.outer.uniskip", index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: "as_is", degree: 27 },
-    Stage1SumcheckInstanceResultPlan { symbol: "stage1.outer_remaining.instance", source: "stage1.outer_remaining.sumcheck", claim: "stage1.outer_remaining.input", relation: "jolt.stage1.outer.remaining", index: 0, point_arity: 16, num_rounds: 17, round_offset: 1, point_order: "reverse", degree: 3 },
+    Stage1SumcheckInstanceResultPlan { symbol: "stage1.uniskip.instance", source: "stage1.uniskip.sumcheck", claim: "stage1.uniskip.input", relation: Stage1RelationKind::Stage1OuterUniskip, index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::AsIs, degree: 27 },
+    Stage1SumcheckInstanceResultPlan { symbol: "stage1.outer_remaining.instance", source: "stage1.outer_remaining.sumcheck", claim: "stage1.outer_remaining.input", relation: Stage1RelationKind::Stage1OuterRemaining, index: 0, point_arity: 16, num_rounds: 17, round_offset: 1, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 },
 ];
 
 pub const STAGE1_SUMCHECK_EVALS: &[Stage1SumcheckEvalPlan] = &[
@@ -118,46 +109,46 @@ pub const STAGE1_SUMCHECK_EVALS: &[Stage1SumcheckEvalPlan] = &[
 ];
 
 pub const STAGE1_OPENING_CLAIMS: &[Stage1OpeningClaimPlan] = &[
-    Stage1OpeningClaimPlan { symbol: "stage1.uniskip.opening", oracle: "UnivariateSkip", domain: "jolt.stage1_uniskip_domain", point_arity: 1, claim_kind: "virtual", point_source: "stage1.uniskip.instance", eval_source: "stage1.uniskip.eval" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LeftInstructionInput" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RightInstructionInput" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Product", oracle: "Product", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Product" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.ShouldBranch", oracle: "ShouldBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.ShouldBranch" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.PC" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.UnexpandedPC" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Imm" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamAddress", oracle: "RamAddress", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamAddress" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Rs1Value" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Rs2Value" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RdWriteValue" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamReadValue", oracle: "RamReadValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamReadValue" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamWriteValue", oracle: "RamWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamWriteValue" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LeftLookupOperand" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RightLookupOperand" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextUnexpandedPC", oracle: "NextUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextUnexpandedPC" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextPC", oracle: "NextPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextPC" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextIsVirtual", oracle: "NextIsVirtual", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextIsVirtual" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextIsFirstInSequence", oracle: "NextIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextIsFirstInSequence" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LookupOutput" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.ShouldJump", oracle: "ShouldJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.ShouldJump" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAddOperands", oracle: "OpFlagAddOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAddOperands" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagSubtractOperands", oracle: "OpFlagSubtractOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagSubtractOperands" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagMultiplyOperands", oracle: "OpFlagMultiplyOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagMultiplyOperands" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagLoad", oracle: "OpFlagLoad", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagLoad" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagStore", oracle: "OpFlagStore", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagStore" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagJump" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagWriteLookupOutputToRD" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagVirtualInstruction" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAssert", oracle: "OpFlagAssert", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAssert" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", oracle: "OpFlagDoNotUpdateUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagDoNotUpdateUnexpandedPC" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAdvice", oracle: "OpFlagAdvice", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAdvice" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsCompressed", oracle: "OpFlagIsCompressed", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsCompressed" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsFirstInSequence" },
-    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsLastInSequence", oracle: "OpFlagIsLastInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsLastInSequence" },
+    Stage1OpeningClaimPlan { symbol: "stage1.uniskip.opening", oracle: "UnivariateSkip", domain: "jolt.stage1_uniskip_domain", point_arity: 1, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.uniskip.instance", eval_source: "stage1.uniskip.eval" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LeftInstructionInput" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RightInstructionInput" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Product", oracle: "Product", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Product" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.ShouldBranch", oracle: "ShouldBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.ShouldBranch" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.PC" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.UnexpandedPC" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Imm" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamAddress", oracle: "RamAddress", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamAddress" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Rs1Value" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Rs2Value" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RdWriteValue" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamReadValue", oracle: "RamReadValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamReadValue" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamWriteValue", oracle: "RamWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamWriteValue" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LeftLookupOperand" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RightLookupOperand" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextUnexpandedPC", oracle: "NextUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextUnexpandedPC" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextPC", oracle: "NextPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextPC" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextIsVirtual", oracle: "NextIsVirtual", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextIsVirtual" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextIsFirstInSequence", oracle: "NextIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextIsFirstInSequence" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LookupOutput" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.ShouldJump", oracle: "ShouldJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.ShouldJump" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAddOperands", oracle: "OpFlagAddOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAddOperands" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagSubtractOperands", oracle: "OpFlagSubtractOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagSubtractOperands" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagMultiplyOperands", oracle: "OpFlagMultiplyOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagMultiplyOperands" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagLoad", oracle: "OpFlagLoad", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagLoad" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagStore", oracle: "OpFlagStore", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagStore" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagJump" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagWriteLookupOutputToRD" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagVirtualInstruction" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAssert", oracle: "OpFlagAssert", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAssert" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", oracle: "OpFlagDoNotUpdateUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagDoNotUpdateUnexpandedPC" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAdvice", oracle: "OpFlagAdvice", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAdvice" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsCompressed", oracle: "OpFlagIsCompressed", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsCompressed" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsFirstInSequence" },
+    Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsLastInSequence", oracle: "OpFlagIsLastInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsLastInSequence" },
 ];
 
 pub const STAGE1_OPENING_BATCHES: &[Stage1OpeningBatchPlan] = &[
-    Stage1OpeningBatchPlan { symbol: "stage1.outer_remaining.openings", stage: "stage1", proof_slot: "stage1.virtual_openings", policy: "jolt_r1cs_input_order", count: 35, ordered_claims: "stage1.outer_remaining.opening.LeftInstructionInput|stage1.outer_remaining.opening.RightInstructionInput|stage1.outer_remaining.opening.Product|stage1.outer_remaining.opening.ShouldBranch|stage1.outer_remaining.opening.PC|stage1.outer_remaining.opening.UnexpandedPC|stage1.outer_remaining.opening.Imm|stage1.outer_remaining.opening.RamAddress|stage1.outer_remaining.opening.Rs1Value|stage1.outer_remaining.opening.Rs2Value|stage1.outer_remaining.opening.RdWriteValue|stage1.outer_remaining.opening.RamReadValue|stage1.outer_remaining.opening.RamWriteValue|stage1.outer_remaining.opening.LeftLookupOperand|stage1.outer_remaining.opening.RightLookupOperand|stage1.outer_remaining.opening.NextUnexpandedPC|stage1.outer_remaining.opening.NextPC|stage1.outer_remaining.opening.NextIsVirtual|stage1.outer_remaining.opening.NextIsFirstInSequence|stage1.outer_remaining.opening.LookupOutput|stage1.outer_remaining.opening.ShouldJump|stage1.outer_remaining.opening.OpFlagAddOperands|stage1.outer_remaining.opening.OpFlagSubtractOperands|stage1.outer_remaining.opening.OpFlagMultiplyOperands|stage1.outer_remaining.opening.OpFlagLoad|stage1.outer_remaining.opening.OpFlagStore|stage1.outer_remaining.opening.OpFlagJump|stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD|stage1.outer_remaining.opening.OpFlagVirtualInstruction|stage1.outer_remaining.opening.OpFlagAssert|stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC|stage1.outer_remaining.opening.OpFlagAdvice|stage1.outer_remaining.opening.OpFlagIsCompressed|stage1.outer_remaining.opening.OpFlagIsFirstInSequence|stage1.outer_remaining.opening.OpFlagIsLastInSequence", claim_operands: "stage1.outer_remaining.opening.LeftInstructionInput|stage1.outer_remaining.opening.RightInstructionInput|stage1.outer_remaining.opening.Product|stage1.outer_remaining.opening.ShouldBranch|stage1.outer_remaining.opening.PC|stage1.outer_remaining.opening.UnexpandedPC|stage1.outer_remaining.opening.Imm|stage1.outer_remaining.opening.RamAddress|stage1.outer_remaining.opening.Rs1Value|stage1.outer_remaining.opening.Rs2Value|stage1.outer_remaining.opening.RdWriteValue|stage1.outer_remaining.opening.RamReadValue|stage1.outer_remaining.opening.RamWriteValue|stage1.outer_remaining.opening.LeftLookupOperand|stage1.outer_remaining.opening.RightLookupOperand|stage1.outer_remaining.opening.NextUnexpandedPC|stage1.outer_remaining.opening.NextPC|stage1.outer_remaining.opening.NextIsVirtual|stage1.outer_remaining.opening.NextIsFirstInSequence|stage1.outer_remaining.opening.LookupOutput|stage1.outer_remaining.opening.ShouldJump|stage1.outer_remaining.opening.OpFlagAddOperands|stage1.outer_remaining.opening.OpFlagSubtractOperands|stage1.outer_remaining.opening.OpFlagMultiplyOperands|stage1.outer_remaining.opening.OpFlagLoad|stage1.outer_remaining.opening.OpFlagStore|stage1.outer_remaining.opening.OpFlagJump|stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD|stage1.outer_remaining.opening.OpFlagVirtualInstruction|stage1.outer_remaining.opening.OpFlagAssert|stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC|stage1.outer_remaining.opening.OpFlagAdvice|stage1.outer_remaining.opening.OpFlagIsCompressed|stage1.outer_remaining.opening.OpFlagIsFirstInSequence|stage1.outer_remaining.opening.OpFlagIsLastInSequence" },
+    Stage1OpeningBatchPlan { symbol: "stage1.outer_remaining.openings", stage: "stage1", proof_slot: "stage1.virtual_openings", policy: "jolt_r1cs_input_order", count: 35, ordered_claims: &["stage1.outer_remaining.opening.LeftInstructionInput", "stage1.outer_remaining.opening.RightInstructionInput", "stage1.outer_remaining.opening.Product", "stage1.outer_remaining.opening.ShouldBranch", "stage1.outer_remaining.opening.PC", "stage1.outer_remaining.opening.UnexpandedPC", "stage1.outer_remaining.opening.Imm", "stage1.outer_remaining.opening.RamAddress", "stage1.outer_remaining.opening.Rs1Value", "stage1.outer_remaining.opening.Rs2Value", "stage1.outer_remaining.opening.RdWriteValue", "stage1.outer_remaining.opening.RamReadValue", "stage1.outer_remaining.opening.RamWriteValue", "stage1.outer_remaining.opening.LeftLookupOperand", "stage1.outer_remaining.opening.RightLookupOperand", "stage1.outer_remaining.opening.NextUnexpandedPC", "stage1.outer_remaining.opening.NextPC", "stage1.outer_remaining.opening.NextIsVirtual", "stage1.outer_remaining.opening.NextIsFirstInSequence", "stage1.outer_remaining.opening.LookupOutput", "stage1.outer_remaining.opening.ShouldJump", "stage1.outer_remaining.opening.OpFlagAddOperands", "stage1.outer_remaining.opening.OpFlagSubtractOperands", "stage1.outer_remaining.opening.OpFlagMultiplyOperands", "stage1.outer_remaining.opening.OpFlagLoad", "stage1.outer_remaining.opening.OpFlagStore", "stage1.outer_remaining.opening.OpFlagJump", "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", "stage1.outer_remaining.opening.OpFlagVirtualInstruction", "stage1.outer_remaining.opening.OpFlagAssert", "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", "stage1.outer_remaining.opening.OpFlagAdvice", "stage1.outer_remaining.opening.OpFlagIsCompressed", "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", "stage1.outer_remaining.opening.OpFlagIsLastInSequence"], claim_operands: &["stage1.outer_remaining.opening.LeftInstructionInput", "stage1.outer_remaining.opening.RightInstructionInput", "stage1.outer_remaining.opening.Product", "stage1.outer_remaining.opening.ShouldBranch", "stage1.outer_remaining.opening.PC", "stage1.outer_remaining.opening.UnexpandedPC", "stage1.outer_remaining.opening.Imm", "stage1.outer_remaining.opening.RamAddress", "stage1.outer_remaining.opening.Rs1Value", "stage1.outer_remaining.opening.Rs2Value", "stage1.outer_remaining.opening.RdWriteValue", "stage1.outer_remaining.opening.RamReadValue", "stage1.outer_remaining.opening.RamWriteValue", "stage1.outer_remaining.opening.LeftLookupOperand", "stage1.outer_remaining.opening.RightLookupOperand", "stage1.outer_remaining.opening.NextUnexpandedPC", "stage1.outer_remaining.opening.NextPC", "stage1.outer_remaining.opening.NextIsVirtual", "stage1.outer_remaining.opening.NextIsFirstInSequence", "stage1.outer_remaining.opening.LookupOutput", "stage1.outer_remaining.opening.ShouldJump", "stage1.outer_remaining.opening.OpFlagAddOperands", "stage1.outer_remaining.opening.OpFlagSubtractOperands", "stage1.outer_remaining.opening.OpFlagMultiplyOperands", "stage1.outer_remaining.opening.OpFlagLoad", "stage1.outer_remaining.opening.OpFlagStore", "stage1.outer_remaining.opening.OpFlagJump", "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", "stage1.outer_remaining.opening.OpFlagVirtualInstruction", "stage1.outer_remaining.opening.OpFlagAssert", "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", "stage1.outer_remaining.opening.OpFlagAdvice", "stage1.outer_remaining.opening.OpFlagIsCompressed", "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", "stage1.outer_remaining.opening.OpFlagIsLastInSequence"] },
 ];
 pub const STAGE1_PROGRAM: Stage1VerifierProgramPlan = Stage1VerifierProgramPlan {
     params: STAGE1_PARAMS,
@@ -236,10 +227,17 @@ where
             reason: "driver symbol mismatch",
         });
     }
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage1Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     match relation {
-        "jolt.stage1.outer.uniskip" => verify_outer_uniskip(program, driver, proof, transcript),
-        "jolt.stage1.outer.remaining" => {
+        Stage1RelationKind::Stage1OuterUniskip => {
+            verify_outer_uniskip(program, driver, proof, transcript)
+        }
+        Stage1RelationKind::Stage1OuterRemaining => {
             verify_outer_remaining(program, driver, proof, completed, transcript)
         }
         relation => Err(VerifyStage1Error::UnsupportedRelation { relation }),
diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs
index 065ee77697..61880aa817 100644
--- a/crates/jolt-verifier/src/stages/stage2.rs
+++ b/crates/jolt-verifier/src/stages/stage2.rs
@@ -1,33 +1,41 @@
 #![allow(dead_code)]
 
-use super::common::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, pow_field, require_operand_count, reverse_slice, single_operand};
-use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt, RingCore};
-use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval};
-use jolt_poly::{EqPolynomial, UnivariatePoly};
+use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, find_batch, find_plan, reverse_slice};
+use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt};
+use jolt_poly::UnivariatePoly;
 use jolt_sumcheck::{CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier};
 use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};
 
 pub type DefaultStage2Transcript = Blake2bTranscript<Fr>;
 
-pub type Stage2NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage2SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage2ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage2ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage2Proof<F> = super::common::StageProof<F>;
-pub type Stage2OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-pub type Stage2VerifierProgramPlan = super::common::StageVerifierProgramPlanNoEqualities;
-
-pub use super::common::{
-    FieldConstantPlan as Stage2FieldConstantPlan, FieldExprPlan as Stage2FieldExprPlan,
+pub type Stage2NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage2SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage2ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage2ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage2Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage2OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage2VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlan<Stage2RelationKind>;
+pub type Stage2SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage2RelationKind>;
+pub type Stage2SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage2RelationKind>;
+pub type Stage2SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage2RelationKind>;
+pub type Stage2RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage2RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage2RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan,
+    FieldExprKind as Stage2FieldExprKind,
+    FieldExprPlan as Stage2FieldExprPlan,
+    OpeningClaimEqualityPlan as Stage2OpeningClaimEqualityPlan,
+    ScalarExprPlan as Stage2ScalarExprPlan,
+    ScalarExprKind as Stage2ScalarExprKind,
     OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan,
-    OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan,
-    PointSlicePlan as Stage2PointSlicePlan, ProgramStepPlan as Stage2ProgramStepPlan,
-    StageParams as Stage2Params, SumcheckBatchPlan as Stage2SumcheckBatchPlan,
+    OpeningInputPlan as Stage2OpeningInputPlan, PointExprKind as Stage2PointExprKind,
+    PointExprPlan as Stage2PointExprPlan, ProgramStepKind as Stage2ProgramStepKind,
+    ProgramStepPlan as Stage2ProgramStepPlan, StageParams as Stage2Params,
+    SumcheckBatchPlan as Stage2SumcheckBatchPlan,
     SumcheckEvalPlan as Stage2SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage2SumcheckInstanceResultPlan,
+    TranscriptSqueezeKind as Stage2TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage2TranscriptSqueezePlan,
-    SumcheckClaimPlan as Stage2SumcheckClaimPlan,
-    SumcheckDriverPlan as Stage2SumcheckDriverPlan,
 };
 
 #[derive(Clone, Copy, Debug)]
@@ -54,7 +62,7 @@ pub struct Stage2RamData<'a> {
 }
 
 #[derive(Clone, Debug, Default)]
-struct Stage2ValueStore<F: Field>(super::common::ValueStore<F>);
+struct Stage2ValueStore<F: Field>(bolt_verifier_runtime::ValueStore<F>);
 
 #[derive(Debug)]
 pub enum VerifyStage2Error {
@@ -65,117 +73,139 @@ pub enum VerifyStage2Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
-    MissingRam { relation: &'static str },
+    UnsupportedRelation { relation: Stage2RelationKind },
+    MissingRam { context: &'static str },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error);
 
-pub const STAGE2_PARAMS: Stage2Params = Stage2Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE2_PARAMS: Stage2Params = Stage2Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE2_PROGRAM_STEPS: &[Stage2ProgramStepPlan] = &[
-    Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.product_virtual.tau_high" },
-    Stage2ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage2.product_virtual.uniskip.sumcheck" },
-    Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.ram_read_write.gamma" },
-    Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.instruction_lookup.gamma" },
-    Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.ram_output.r_address" },
-    Stage2ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage2.sumcheck" },
+    Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::TranscriptSqueeze, symbol: "stage2.product_virtual.tau_high" },
+    Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::SumcheckDriver, symbol: "stage2.product_virtual.uniskip.sumcheck" },
+    Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::TranscriptSqueeze, symbol: "stage2.ram_read_write.gamma" },
+    Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::TranscriptSqueeze, symbol: "stage2.instruction_lookup.gamma" },
+    Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::TranscriptSqueeze, symbol: "stage2.ram_output.r_address" },
+    Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::SumcheckDriver, symbol: "stage2.sumcheck" },
 ];
 
 pub const STAGE2_TRANSCRIPT_SQUEEZES: &[Stage2TranscriptSqueezePlan] = &[
-    Stage2TranscriptSqueezePlan { symbol: "stage2.product_virtual.tau_high", label: "product_virtual_tau_high", kind: "challenge_scalar", count: 1 },
-    Stage2TranscriptSqueezePlan { symbol: "stage2.ram_read_write.gamma", label: "ram_read_write_gamma", kind: "challenge_scalar", count: 1 },
-    Stage2TranscriptSqueezePlan { symbol: "stage2.instruction_lookup.gamma", label: "instruction_lookup_gamma", kind: "challenge_scalar", count: 1 },
-    Stage2TranscriptSqueezePlan { symbol: "stage2.ram_output.r_address", label: "ram_output_r_address", kind: "challenge_vector", count: 16 },
+    Stage2TranscriptSqueezePlan { symbol: "stage2.product_virtual.tau_high", label: "product_virtual_tau_high", kind: Stage2TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage2TranscriptSqueezePlan { symbol: "stage2.ram_read_write.gamma", label: "ram_read_write_gamma", kind: Stage2TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage2TranscriptSqueezePlan { symbol: "stage2.instruction_lookup.gamma", label: "instruction_lookup_gamma", kind: Stage2TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage2TranscriptSqueezePlan { symbol: "stage2.ram_output.r_address", label: "ram_output_r_address", kind: Stage2TranscriptSqueezeKind::ChallengeVector, count: 16 },
 ];
 
 pub const STAGE2_OPENING_INPUTS: &[Stage2OpeningInputPlan] = &[
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.Product", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Product", oracle: "Product", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.ShouldBranch", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.ShouldBranch", oracle: "ShouldBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.ShouldJump", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.ShouldJump", oracle: "ShouldJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamReadValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamReadValue", oracle: "RamReadValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamWriteValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamWriteValue", oracle: "RamWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LookupOutput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LeftLookupOperand", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RightLookupOperand", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LeftInstructionInput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RightInstructionInput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamAddress", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamAddress", oracle: "RamAddress", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.Product", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Product", oracle: "Product", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.ShouldBranch", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.ShouldBranch", oracle: "ShouldBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.ShouldJump", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.ShouldJump", oracle: "ShouldJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamReadValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamReadValue", oracle: "RamReadValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamWriteValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamWriteValue", oracle: "RamWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LookupOutput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LeftLookupOperand", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RightLookupOperand", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LeftInstructionInput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RightInstructionInput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
+    Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamAddress", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamAddress", oracle: "RamAddress", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual },
 ];
 
 pub const STAGE2_FIELD_CONSTANTS: &[Stage2FieldConstantPlan] = &[
     Stage2FieldConstantPlan { symbol: "stage2.ram_output.zero", field: "bn254_fr", value: 0 },
+    Stage2FieldConstantPlan { symbol: "stage2.product_virtual.remainder.one", field: "bn254_fr", value: 1 },
 ];
 
 pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[
-    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.Product", kind: "op", formula: "poly.lagrange_basis_eval:-1:3:0", operands: "stage2.product_virtual.tau_high" },
-    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldBranch", kind: "op", formula: "poly.lagrange_basis_eval:-1:3:1", operands: "stage2.product_virtual.tau_high" },
-    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldJump", kind: "op", formula: "poly.lagrange_basis_eval:-1:3:2", operands: "stage2.product_virtual.tau_high" },
-    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.Product", kind: "op", formula: "field.mul", operands: "stage2.product_virtual.uniskip.weight.Product|stage2.input.stage1.Product" },
-    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldBranch", kind: "op", formula: "field.mul", operands: "stage2.product_virtual.uniskip.weight.ShouldBranch|stage2.input.stage1.ShouldBranch" },
-    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldJump", kind: "op", formula: "field.mul", operands: "stage2.product_virtual.uniskip.weight.ShouldJump|stage2.input.stage1.ShouldJump" },
-    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.partial.ProductShouldBranch", kind: "op", formula: "field.add", operands: "stage2.product_virtual.uniskip.term.Product|stage2.product_virtual.uniskip.term.ShouldBranch" },
-    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.claim_expr", kind: "op", formula: "field.add", operands: "stage2.product_virtual.uniskip.partial.ProductShouldBranch|stage2.product_virtual.uniskip.term.ShouldJump" },
-    Stage2FieldExprPlan { symbol: "stage2.ram_read_write.term.RamWriteValue", kind: "op", formula: "field.mul", operands: "stage2.ram_read_write.gamma|stage2.input.stage1.RamWriteValue" },
-    Stage2FieldExprPlan { symbol: "stage2.ram_read_write.claim_expr", kind: "op", formula: "field.add", operands: "stage2.input.stage1.RamReadValue|stage2.ram_read_write.term.RamWriteValue" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma2", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma|stage2.instruction_lookup.gamma" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma3", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma2|stage2.instruction_lookup.gamma" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma4", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma2|stage2.instruction_lookup.gamma2" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftLookupOperand", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma|stage2.input.stage1.LeftLookupOperand" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightLookupOperand", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma2|stage2.input.stage1.RightLookupOperand" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftInstructionInput", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma3|stage2.input.stage1.LeftInstructionInput" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightInstructionInput", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma4|stage2.input.stage1.RightInstructionInput" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LookupOutputLeftOperand", kind: "op", formula: "field.add", operands: "stage2.input.stage1.LookupOutput|stage2.instruction_lookup.term.LeftLookupOperand" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.RightOperand", kind: "op", formula: "field.add", operands: "stage2.instruction_lookup.partial.LookupOutputLeftOperand|stage2.instruction_lookup.term.RightLookupOperand" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LeftInstructionInput", kind: "op", formula: "field.add", operands: "stage2.instruction_lookup.partial.RightOperand|stage2.instruction_lookup.term.LeftInstructionInput" },
-    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: "op", formula: "field.add", operands: "stage2.instruction_lookup.partial.LeftInstructionInput|stage2.instruction_lookup.term.RightInstructionInput" },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.Product", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 0), operands: &["stage2.product_virtual.tau_high"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldBranch", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 1), operands: &["stage2.product_virtual.tau_high"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldJump", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 2), operands: &["stage2.product_virtual.tau_high"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.Product", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.uniskip.weight.Product", "stage2.input.stage1.Product"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldBranch", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.uniskip.weight.ShouldBranch", "stage2.input.stage1.ShouldBranch"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldJump", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.uniskip.weight.ShouldJump", "stage2.input.stage1.ShouldJump"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.partial.ProductShouldBranch", kind: Stage2FieldExprKind::Add, operands: &["stage2.product_virtual.uniskip.term.Product", "stage2.product_virtual.uniskip.term.ShouldBranch"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.product_virtual.uniskip.partial.ProductShouldBranch", "stage2.product_virtual.uniskip.term.ShouldJump"] },
+    Stage2FieldExprPlan { symbol: "stage2.ram_read_write.term.RamWriteValue", kind: Stage2FieldExprKind::Mul, operands: &["stage2.ram_read_write.gamma", "stage2.input.stage1.RamWriteValue"] },
+    Stage2FieldExprPlan { symbol: "stage2.ram_read_write.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.input.stage1.RamReadValue", "stage2.ram_read_write.term.RamWriteValue"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma2", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma", "stage2.instruction_lookup.gamma"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma3", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma2", "stage2.instruction_lookup.gamma"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma4", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma2", "stage2.instruction_lookup.gamma2"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftLookupOperand", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma", "stage2.input.stage1.LeftLookupOperand"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightLookupOperand", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma2", "stage2.input.stage1.RightLookupOperand"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma3", "stage2.input.stage1.LeftInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma4", "stage2.input.stage1.RightInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LookupOutputLeftOperand", kind: Stage2FieldExprKind::Add, operands: &["stage2.input.stage1.LookupOutput", "stage2.instruction_lookup.term.LeftLookupOperand"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.RightOperand", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LookupOutputLeftOperand", "stage2.instruction_lookup.term.RightLookupOperand"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.RightOperand", "stage2.instruction_lookup.term.LeftInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LeftInstructionInput", "stage2.instruction_lookup.term.RightInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.partial.ValPlusInc", kind: Stage2FieldExprKind::Add, operands: &["stage2.ram_read_write.eval.RamVal", "stage2.ram_read_write.eval.RamInc"] },
+    Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.term.GammaValPlusInc", kind: Stage2FieldExprKind::Mul, operands: &["stage2.ram_read_write.gamma", "stage2.ram_read_write.output.partial.ValPlusInc"] },
+    Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.partial.WeightedVal", kind: Stage2FieldExprKind::Add, operands: &["stage2.ram_read_write.eval.RamVal", "stage2.ram_read_write.output.term.GammaValPlusInc"] },
+    Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.claim_expr", kind: Stage2FieldExprKind::Product, operands: &["stage2.ram_read_write.output.eq.Cycle", "stage2.ram_read_write.eval.RamRa", "stage2.ram_read_write.output.partial.WeightedVal"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.term.LeftLookupOperand", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma", "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.term.RightLookupOperand", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma2", "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.term.LeftInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma3", "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.term.RightInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma4", "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.partial.LookupOutputLeftOperand", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.claim_reduction.eval.LookupOutput", "stage2.instruction_lookup.output.term.LeftLookupOperand"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.partial.RightOperand", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.output.partial.LookupOutputLeftOperand", "stage2.instruction_lookup.output.term.RightLookupOperand"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.output.partial.RightOperand", "stage2.instruction_lookup.output.term.LeftInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.weighted_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.output.partial.LeftInstructionInput", "stage2.instruction_lookup.output.term.RightInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.claim_expr", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.output.eq.LookupOutput", "stage2.instruction_lookup.output.weighted_expr"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.high", kind: Stage2FieldExprKind::LagrangeKernelEval(-1, 3), operands: &["stage2.product_virtual.tau_high", "stage2.product_virtual.remainder.point.UniskipR0"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.weight.Product", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 0), operands: &["stage2.product_virtual.remainder.point.UniskipR0"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.weight.ShouldBranch", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 1), operands: &["stage2.product_virtual.remainder.point.UniskipR0"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.weight.ShouldJump", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 2), operands: &["stage2.product_virtual.remainder.point.UniskipR0"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.left.LeftInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.Product", "stage2.product_virtual.remainder.eval.LeftInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.left.LookupOutput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.ShouldBranch", "stage2.product_virtual.remainder.eval.LookupOutput"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.left.OpFlagJump", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.ShouldJump", "stage2.product_virtual.remainder.eval.OpFlagJump"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.left.weighted_expr", kind: Stage2FieldExprKind::Sum, operands: &["stage2.product_virtual.remainder.output.left.LeftInstructionInput", "stage2.product_virtual.remainder.output.left.LookupOutput", "stage2.product_virtual.remainder.output.left.OpFlagJump"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.RightInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.Product", "stage2.product_virtual.remainder.eval.RightInstructionInput"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.InstructionFlagBranch", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.ShouldBranch", "stage2.product_virtual.remainder.eval.InstructionFlagBranch"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.partial.NotNextIsNoop", kind: Stage2FieldExprKind::Sub, operands: &["stage2.product_virtual.remainder.one", "stage2.product_virtual.remainder.eval.NextIsNoop"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.NextIsNoop", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.ShouldJump", "stage2.product_virtual.remainder.output.partial.NotNextIsNoop"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.weighted_expr", kind: Stage2FieldExprKind::Sum, operands: &["stage2.product_virtual.remainder.output.right.RightInstructionInput", "stage2.product_virtual.remainder.output.right.InstructionFlagBranch", "stage2.product_virtual.remainder.output.right.NextIsNoop"] },
+    Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.claim_expr", kind: Stage2FieldExprKind::Product, operands: &["stage2.product_virtual.remainder.output.high", "stage2.product_virtual.remainder.output.eq.Product", "stage2.product_virtual.remainder.output.left.weighted_expr", "stage2.product_virtual.remainder.output.right.weighted_expr"] },
+    Stage2FieldExprPlan { symbol: "stage2.ram_raf.output.claim_expr", kind: Stage2FieldExprKind::Mul, operands: &["stage2.ram_raf.output.unmap", "stage2.ram_raf.eval.RamRa"] },
+    Stage2FieldExprPlan { symbol: "stage2.ram_output.output.partial.ValFinalMinusIo", kind: Stage2FieldExprKind::Sub, operands: &["stage2.ram_output.eval.RamValFinal", "stage2.ram_output.output.val_io"] },
+    Stage2FieldExprPlan { symbol: "stage2.ram_output.output.claim_expr", kind: Stage2FieldExprKind::Product, operands: &["stage2.ram_output.output.eq", "stage2.ram_output.output.io_mask", "stage2.ram_output.output.partial.ValFinalMinusIo"] },
 ];
-pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[
-    Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some("jolt.stage2.product_virtual.uniskip"), claim_value: "stage2.product_virtual.uniskip.claim_expr", input_openings: "stage2.input.stage1.Product|stage2.input.stage1.ShouldBranch|stage2.input.stage1.ShouldJump" },
-    Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some("jolt.stage2.ram.read_write"), claim_value: "stage2.ram_read_write.claim_expr", input_openings: "stage2.input.stage1.RamReadValue|stage2.input.stage1.RamWriteValue" },
-    Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.remainder.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage2.product_virtual.uniskip.opening", kernel: None, relation: Some("jolt.stage2.product_virtual.remainder"), claim_value: "stage2.product_virtual.uniskip.eval.UnivariateSkip", input_openings: "stage2.product_virtual.uniskip.opening.UnivariateSkip" },
-    Stage2SumcheckClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage2.instruction_lookup.weighted_operands", kernel: None, relation: Some("jolt.stage2.instruction_lookup.claim_reduction"), claim_value: "stage2.instruction_lookup.claim_reduction.claim_expr", input_openings: "stage2.input.stage1.LookupOutput|stage2.input.stage1.LeftLookupOperand|stage2.input.stage1.RightLookupOperand|stage2.input.stage1.LeftInstructionInput|stage2.input.stage1.RightInstructionInput" },
-    Stage2SumcheckClaimPlan { symbol: "stage2.ram_raf.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 2, claim: "stage2.ram_raf.ram_address", kernel: None, relation: Some("jolt.stage2.ram.raf_evaluation"), claim_value: "stage2.input.stage1.RamAddress", input_openings: "stage2.input.stage1.RamAddress" },
-    Stage2SumcheckClaimPlan { symbol: "stage2.ram_output.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 3, claim: "zero", kernel: None, relation: Some("jolt.stage2.ram.output_check"), claim_value: "stage2.ram_output.zero", input_openings: "" },
+pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[
+    Stage2ScalarExprPlan { symbol: "stage2.ram_read_write.output.eq.Cycle", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.ram_read_write.instance", "stage2.input.stage1.RamReadValue"] },
+    Stage2ScalarExprPlan { symbol: "stage2.instruction_lookup.output.eq.LookupOutput", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.instruction_lookup.claim_reduction.instance", "stage2.input.stage1.LookupOutput"] },
+    Stage2ScalarExprPlan { symbol: "stage2.product_virtual.remainder.point.UniskipR0", kind: Stage2ScalarExprKind::PointElement { index: 0 }, operands: &["stage2.product_virtual.uniskip.sumcheck"] },
+    Stage2ScalarExprPlan { symbol: "stage2.product_virtual.remainder.output.eq.Product", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.product_virtual.remainder.instance", "stage2.input.stage1.Product"] },
 ];
-pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    1,
+pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[
+    Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr" },
+    Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some(Stage2RelationKind::Stage2RamReadWrite), claim_value: "stage2.ram_read_write.claim_expr" },
+    Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.remainder.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage2.product_virtual.uniskip.opening", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualRemainder), claim_value: "stage2.product_virtual.uniskip.eval.UnivariateSkip" },
+    Stage2SumcheckClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage2.instruction_lookup.weighted_operands", kernel: None, relation: Some(Stage2RelationKind::Stage2InstructionLookupClaimReduction), claim_value: "stage2.instruction_lookup.claim_reduction.claim_expr" },
+    Stage2SumcheckClaimPlan { symbol: "stage2.ram_raf.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 2, claim: "stage2.ram_raf.ram_address", kernel: None, relation: Some(Stage2RelationKind::Stage2RamRafEvaluation), claim_value: "stage2.input.stage1.RamAddress" },
+    Stage2SumcheckClaimPlan { symbol: "stage2.ram_output.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 3, claim: "zero", kernel: None, relation: Some(Stage2RelationKind::Stage2RamOutputCheck), claim_value: "stage2.ram_output.zero" },
 ];
+pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1];
 
-pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[
-    16,
-    16,
-];
+pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[16, 16];
 
 pub const STAGE2_SUMCHECK_BATCHES: &[Stage2SumcheckBatchPlan] = &[
-    Stage2SumcheckBatchPlan { symbol: "stage2.product_virtual.uniskip.batch", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: "stage2.product_virtual.uniskip.input", claim_operands: "stage2.product_virtual.uniskip.input", claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
-    Stage2SumcheckBatchPlan { symbol: "stage2.batch", stage: "stage2", proof_slot: "stage2.sumcheck", policy: "jolt_core_stage2_aligned", count: 5, ordered_claims: "stage2.ram_read_write.input|stage2.product_virtual.remainder.input|stage2.instruction_lookup.claim_reduction.input|stage2.ram_raf.input|stage2.ram_output.input", claim_operands: "stage2.ram_read_write.input|stage2.product_virtual.remainder.input|stage2.instruction_lookup.claim_reduction.input|stage2.ram_raf.input|stage2.ram_output.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE },
-];
-pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    1,
+    Stage2SumcheckBatchPlan { symbol: "stage2.product_virtual.uniskip.batch", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", policy: "single_instance", count: 1, claim_operands: &["stage2.product_virtual.uniskip.input"], claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
+    Stage2SumcheckBatchPlan { symbol: "stage2.batch", stage: "stage2", proof_slot: "stage2.sumcheck", policy: "jolt_core_stage2_aligned", count: 5, claim_operands: &["stage2.ram_read_write.input", "stage2.product_virtual.remainder.input", "stage2.instruction_lookup.claim_reduction.input", "stage2.ram_raf.input", "stage2.ram_output.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE },
 ];
+pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1];
 
-pub const STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[
-    16,
-    16,
-];
+pub const STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[16, 16];
 
 pub const STAGE2_SUMCHECK_DRIVERS: &[Stage2SumcheckDriverPlan] = &[
-    Stage2SumcheckDriverPlan { symbol: "stage2.product_virtual.uniskip.sumcheck", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", kernel: None, relation: Some("jolt.stage2.product_virtual.uniskip"), batch: "stage2.product_virtual.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 6 },
-    Stage2SumcheckDriverPlan { symbol: "stage2.sumcheck", stage: "stage2", proof_slot: "stage2.sumcheck", kernel: None, relation: Some("jolt.stage2.batched"), batch: "stage2.batch", policy: "jolt_core_stage2_aligned", round_schedule: STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 32, degree: 3 },
+    Stage2SumcheckDriverPlan { symbol: "stage2.product_virtual.uniskip.sumcheck", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), batch: "stage2.product_virtual.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 6 },
+    Stage2SumcheckDriverPlan { symbol: "stage2.sumcheck", stage: "stage2", proof_slot: "stage2.sumcheck", kernel: None, relation: Some(Stage2RelationKind::Stage2Batched), batch: "stage2.batch", policy: "jolt_core_stage2_aligned", round_schedule: STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 32, degree: 3 },
 ];
 pub const STAGE2_SUMCHECK_INSTANCE_RESULTS: &[Stage2SumcheckInstanceResultPlan] = &[
-    Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.uniskip.instance", source: "stage2.product_virtual.uniskip.sumcheck", claim: "stage2.product_virtual.uniskip.input", relation: "jolt.stage2.product_virtual.uniskip", index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: "as_is", degree: 6 },
-    Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_read_write.instance", source: "stage2.sumcheck", claim: "stage2.ram_read_write.input", relation: "jolt.stage2.ram.read_write", index: 0, point_arity: 32, num_rounds: 32, round_offset: 0, point_order: "reverse", degree: 3 },
-    Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.remainder.instance", source: "stage2.sumcheck", claim: "stage2.product_virtual.remainder.input", relation: "jolt.stage2.product_virtual.remainder", index: 1, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 3 },
-    Stage2SumcheckInstanceResultPlan { symbol: "stage2.instruction_lookup.claim_reduction.instance", source: "stage2.sumcheck", claim: "stage2.instruction_lookup.claim_reduction.input", relation: "jolt.stage2.instruction_lookup.claim_reduction", index: 2, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 2 },
-    Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_raf.instance", source: "stage2.sumcheck", claim: "stage2.ram_raf.input", relation: "jolt.stage2.ram.raf_evaluation", index: 3, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 2 },
-    Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_output.instance", source: "stage2.sumcheck", claim: "stage2.ram_output.input", relation: "jolt.stage2.ram.output_check", index: 4, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 3 },
+    Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.uniskip.instance", source: "stage2.product_virtual.uniskip.sumcheck", claim: "stage2.product_virtual.uniskip.input", relation: Stage2RelationKind::Stage2ProductVirtualUniskip, index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::AsIs, degree: 6 },
+    Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_read_write.instance", source: "stage2.sumcheck", claim: "stage2.ram_read_write.input", relation: Stage2RelationKind::Stage2RamReadWrite, index: 0, point_arity: 32, num_rounds: 32, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 },
+    Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.remainder.instance", source: "stage2.sumcheck", claim: "stage2.product_virtual.remainder.input", relation: Stage2RelationKind::Stage2ProductVirtualRemainder, index: 1, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 },
+    Stage2SumcheckInstanceResultPlan { symbol: "stage2.instruction_lookup.claim_reduction.instance", source: "stage2.sumcheck", claim: "stage2.instruction_lookup.claim_reduction.input", relation: Stage2RelationKind::Stage2InstructionLookupClaimReduction, index: 2, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 },
+    Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_raf.instance", source: "stage2.sumcheck", claim: "stage2.ram_raf.input", relation: Stage2RelationKind::Stage2RamRafEvaluation, index: 3, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 },
+    Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_output.instance", source: "stage2.sumcheck", claim: "stage2.ram_output.input", relation: Stage2RelationKind::Stage2RamOutputCheck, index: 4, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 },
 ];
 
 pub const STAGE2_SUMCHECK_EVALS: &[Stage2SumcheckEvalPlan] = &[
@@ -200,38 +230,47 @@ pub const STAGE2_SUMCHECK_EVALS: &[Stage2SumcheckEvalPlan] = &[
     Stage2SumcheckEvalPlan { symbol: "stage2.ram_output.eval.RamValFinal", source: "stage2.sumcheck", name: "stage2.ram_output.eval.RamValFinal", index: 0, oracle: "RamValFinal" },
 ];
 
-pub const STAGE2_POINT_SLICES: &[Stage2PointSlicePlan] = &[
-    Stage2PointSlicePlan { symbol: "stage2.ram_read_write.point.RamInc", source: "stage2.ram_read_write.instance", offset: 16, length: 16, input: "stage2.ram_read_write.instance" },
+pub const STAGE2_POINT_EXPRS: &[Stage2PointExprPlan] = &[
+    Stage2PointExprPlan { symbol: "stage2.ram_read_write.point.RamInc", kind: Stage2PointExprKind::Slice { offset: 16, length: 16 }, operands: &["stage2.ram_read_write.instance"] },
+    Stage2PointExprPlan { symbol: "stage2.ram_raf.point.RamRa", kind: Stage2PointExprKind::Concat { layout: "address_then_cycle", arity: 32 }, operands: &["stage2.ram_raf.instance", "stage2.input.stage1.RamAddress"] },
 ];
 
-pub const STAGE2_POINT_CONCATS: &[Stage2PointConcatPlan] = &[
-    Stage2PointConcatPlan { symbol: "stage2.ram_raf.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: "stage2.ram_raf.instance|stage2.input.stage1.RamAddress" },
-];
 pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[
-    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.uniskip.opening.UnivariateSkip", oracle: "UnivariateSkip", domain: "jolt.stage2_uniskip_domain", point_arity: 1, claim_kind: "virtual", point_source: "stage2.product_virtual.uniskip.instance", eval_source: "stage2.product_virtual.uniskip.eval.UnivariateSkip" },
-    Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamVal", oracle: "RamVal", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage2.ram_read_write.instance", eval_source: "stage2.ram_read_write.eval.RamVal" },
-    Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage2.ram_read_write.instance", eval_source: "stage2.ram_read_write.eval.RamRa" },
-    Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage2.ram_read_write.point.RamInc", eval_source: "stage2.ram_read_write.eval.RamInc" },
-    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.LeftInstructionInput" },
-    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.RightInstructionInput" },
-    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagJump" },
-    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagWriteLookupOutputToRD" },
-    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.LookupOutput" },
-    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.InstructionFlagBranch", oracle: "InstructionFlagBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.InstructionFlagBranch" },
-    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.NextIsNoop", oracle: "NextIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.NextIsNoop" },
-    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagVirtualInstruction" },
-    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LookupOutput" },
-    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand" },
-    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand" },
-    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput" },
-    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput" },
-    Stage2OpeningClaimPlan { symbol: "stage2.ram_raf.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage2.ram_raf.point.RamRa", eval_source: "stage2.ram_raf.eval.RamRa" },
-    Stage2OpeningClaimPlan { symbol: "stage2.ram_output.opening.RamValFinal", oracle: "RamValFinal", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.ram_output.instance", eval_source: "stage2.ram_output.eval.RamValFinal" },
+    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.uniskip.opening.UnivariateSkip", oracle: "UnivariateSkip", domain: "jolt.stage2_uniskip_domain", point_arity: 1, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.uniskip.instance", eval_source: "stage2.product_virtual.uniskip.eval.UnivariateSkip" },
+    Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamVal", oracle: "RamVal", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_read_write.instance", eval_source: "stage2.ram_read_write.eval.RamVal" },
+    Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_read_write.instance", eval_source: "stage2.ram_read_write.eval.RamRa" },
+    Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Committed, point_source: "stage2.ram_read_write.point.RamInc", eval_source: "stage2.ram_read_write.eval.RamInc" },
+    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.LeftInstructionInput" },
+    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.RightInstructionInput" },
+    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagJump" },
+    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagWriteLookupOutputToRD" },
+    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.LookupOutput" },
+    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.InstructionFlagBranch", oracle: "InstructionFlagBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.InstructionFlagBranch" },
+    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.NextIsNoop", oracle: "NextIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.NextIsNoop" },
+    Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagVirtualInstruction" },
+    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LookupOutput" },
+    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand" },
+    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand" },
+    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput" },
+    Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput" },
+    Stage2OpeningClaimPlan { symbol: "stage2.ram_raf.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_raf.point.RamRa", eval_source: "stage2.ram_raf.eval.RamRa" },
+    Stage2OpeningClaimPlan { symbol: "stage2.ram_output.opening.RamValFinal", oracle: "RamValFinal", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_output.instance", eval_source: "stage2.ram_output.eval.RamValFinal" },
 ];
 
+pub const STAGE2_OPENING_EQUALITIES: &[Stage2OpeningClaimEqualityPlan] = &[];
 pub const STAGE2_OPENING_BATCHES: &[Stage2OpeningBatchPlan] = &[
-    Stage2OpeningBatchPlan { symbol: "stage2.openings", stage: "stage2", proof_slot: "stage2.openings", policy: "jolt_stage2_output_order", count: 18, ordered_claims: "stage2.ram_read_write.opening.RamVal|stage2.ram_read_write.opening.RamRa|stage2.ram_read_write.opening.RamInc|stage2.product_virtual.remainder.opening.LeftInstructionInput|stage2.product_virtual.remainder.opening.RightInstructionInput|stage2.product_virtual.remainder.opening.OpFlagJump|stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD|stage2.product_virtual.remainder.opening.LookupOutput|stage2.product_virtual.remainder.opening.InstructionFlagBranch|stage2.product_virtual.remainder.opening.NextIsNoop|stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction|stage2.instruction_lookup.claim_reduction.opening.LookupOutput|stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand|stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand|stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput|stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput|stage2.ram_raf.opening.RamRa|stage2.ram_output.opening.RamValFinal", claim_operands: "stage2.ram_read_write.opening.RamVal|stage2.ram_read_write.opening.RamRa|stage2.ram_read_write.opening.RamInc|stage2.product_virtual.remainder.opening.LeftInstructionInput|stage2.product_virtual.remainder.opening.RightInstructionInput|stage2.product_virtual.remainder.opening.OpFlagJump|stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD|stage2.product_virtual.remainder.opening.LookupOutput|stage2.product_virtual.remainder.opening.InstructionFlagBranch|stage2.product_virtual.remainder.opening.NextIsNoop|stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction|stage2.instruction_lookup.claim_reduction.opening.LookupOutput|stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand|stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand|stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput|stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput|stage2.ram_raf.opening.RamRa|stage2.ram_output.opening.RamValFinal" },
+    Stage2OpeningBatchPlan { symbol: "stage2.openings", stage: "stage2", proof_slot: "stage2.openings", policy: "jolt_stage2_output_order", count: 18, ordered_claims: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"], claim_operands: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"] },
+];
+pub const STAGE2_RELATION_OUTPUT_3_LOCAL_SCALARS: &[&str] = &["stage2.ram_raf.output.unmap"];
+pub const STAGE2_RELATION_OUTPUT_4_LOCAL_SCALARS: &[&str] = &["stage2.ram_output.output.eq", "stage2.ram_output.output.io_mask", "stage2.ram_output.output.val_io"];
+pub const STAGE2_RELATION_OUTPUTS: &[Stage2RelationOutputPlan] = &[
+    Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2RamReadWrite, local_scalars: &[], expected_output: "stage2.ram_read_write.output.claim_expr" },
+    Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2InstructionLookupClaimReduction, local_scalars: &[], expected_output: "stage2.instruction_lookup.output.claim_expr" },
+    Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2ProductVirtualRemainder, local_scalars: &[], expected_output: "stage2.product_virtual.remainder.output.claim_expr" },
+    Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2RamRafEvaluation, local_scalars: STAGE2_RELATION_OUTPUT_3_LOCAL_SCALARS, expected_output: "stage2.ram_raf.output.claim_expr" },
+    Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2RamOutputCheck, local_scalars: STAGE2_RELATION_OUTPUT_4_LOCAL_SCALARS, expected_output: "stage2.ram_output.output.claim_expr" },
 ];
+
 pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan {
     params: STAGE2_PARAMS,
     steps: STAGE2_PROGRAM_STEPS,
@@ -239,14 +278,16 @@ pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan
     opening_inputs: STAGE2_OPENING_INPUTS,
     field_constants: STAGE2_FIELD_CONSTANTS,
     field_exprs: STAGE2_FIELD_EXPRS,
+    scalar_exprs: STAGE2_SCALAR_EXPRS,
     claims: STAGE2_SUMCHECK_CLAIMS,
     batches: STAGE2_SUMCHECK_BATCHES,
     drivers: STAGE2_SUMCHECK_DRIVERS,
     instance_results: STAGE2_SUMCHECK_INSTANCE_RESULTS,
     evals: STAGE2_SUMCHECK_EVALS,
-    point_slices: STAGE2_POINT_SLICES,
-    point_concats: STAGE2_POINT_CONCATS,
+    relation_outputs: STAGE2_RELATION_OUTPUTS,
+    point_exprs: STAGE2_POINT_EXPRS,
     opening_claims: STAGE2_OPENING_CLAIMS,
+    opening_equalities: STAGE2_OPENING_EQUALITIES,
     opening_batches: STAGE2_OPENING_BATCHES,
 };
 
@@ -294,19 +335,19 @@ where
     } else {
         for step in program.steps {
             match step.kind {
-                "transcript_squeeze" => {
+                Stage2ProgramStepKind::TranscriptSqueeze => {
                     let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage2Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                     verify_stage2_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
                 }
-                "sumcheck_driver" => {
+                Stage2ProgramStepKind::SumcheckDriver => {
                     let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage2Error::MissingProof {
                         driver: step.symbol,
                     })?;
                     verify_stage2_driver(program, driver, proof, ram, &mut store, transcript, &mut artifacts)?;
                 }
-                _ => {
+                Stage2ProgramStepKind::TranscriptAbsorbBytes => {
                     return Err(VerifyStage2Error::InvalidProof {
                         driver: step.symbol,
                         reason: "unsupported stage2 program step",
@@ -369,12 +410,19 @@ where
         .ok_or(VerifyStage2Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage2Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage2.product_virtual.uniskip" => {
+        Stage2RelationKind::Stage2ProductVirtualUniskip => {
             verify_product_virtual_uniskip(program, driver, proof, store, transcript)?
         }
-        "jolt.stage2.batched" => verify_batched_stage2(program, driver, proof, ram, store, transcript)?,
+        Stage2RelationKind::Stage2Batched => {
+            verify_batched_stage2(program, driver, proof, ram, store, transcript)?
+        }
         relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
@@ -485,8 +533,21 @@ where
             reason: "batched point mismatch",
         });
     }
-    let expected =
-        expected_batched_output_claim(program, driver, &*store, &proof.evals, &output.point, &batching_coeffs, ram)?;
+    let expected = bolt_verifier_runtime::evaluate_relation_output_batch(
+        driver,
+        program.batches,
+        program.claims,
+        program.instance_results,
+        program.relation_outputs,
+        program.field_exprs,
+        program.scalar_exprs,
+        &[],
+        &store.0,
+        &proof.evals,
+        &output.point,
+        &batching_coeffs,
+        |instance, _, local_point| stage2_relation_output_inputs(&*store, ram, instance, local_point),
+    )?;
     if output.value != expected {
         return Err(VerifyStage2Error::InvalidProof {
             driver: driver.symbol,
@@ -500,7 +561,7 @@ where
         proof: proof.proof.clone(),
     };
     store.observe_sumcheck_output(program, &verified)?;
-    super::common::append_opening_claims(
+    bolt_verifier_runtime::append_opening_claims(
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
@@ -518,7 +579,7 @@ impl<F: Field> Stage2ValueStore<F> {
         program: &'static Stage2VerifierProgramPlan,
         inputs: &[Stage2OpeningInputValue<F>],
     ) -> Result<Self, VerifyStage2Error> {
-        Ok(Self(super::common::ValueStore::with_opening_inputs(
+        Ok(Self(bolt_verifier_runtime::ValueStore::with_opening_inputs(
             inputs,
             program.opening_inputs,
         )?))
@@ -552,16 +613,16 @@ impl<F: Field> Stage2ValueStore<F> {
             program.evals,
             output,
             |instance, mut point| {
-                match instance.point_order {
-                    "as_is" => {}
-                    "reverse" => point.reverse(),
-                    _ => {
-                        return Err(VerifyStage2Error::InvalidProof {
-                            driver: output.driver,
-                            reason: "unsupported point order",
-                        });
-                    }
+            match instance.point_order {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
+                    return Err(VerifyStage2Error::InvalidProof {
+                        driver: output.driver,
+                        reason: "unsupported relation-local point order",
+                    });
                 }
+            }
                 Ok(point)
             },
             |input, expected, actual| VerifyStage2Error::InvalidInputLength {
@@ -590,7 +651,10 @@ impl<F: Field> Stage2ValueStore<F> {
         program: &'static Stage2VerifierProgramPlan,
         batch: &Stage2SumcheckBatchPlan,
     ) -> Result<Vec<F>, VerifyStage2Error> {
-        super::common::symbol_list(batch.claim_operands)
+        batch
+            .claim_operands
+            .iter()
+            .copied()
             .map(|symbol| {
                 let claim = find_plan(program.claims, symbol).ok_or(VerifyStage2Error::MissingClaim {
                     batch: batch.symbol,
@@ -606,8 +670,7 @@ impl<F: Field> Stage2ValueStore<F> {
         program: &'static Stage2VerifierProgramPlan,
     ) -> Result<(), VerifyStage2Error> {
         self.0.evaluate_available_points(
-            program.point_slices,
-            program.point_concats,
+            program.point_exprs,
             |input, expected, actual| VerifyStage2Error::InvalidInputLength {
                 input,
                 expected,
@@ -621,7 +684,8 @@ impl<F: Field> Stage2ValueStore<F> {
         program: &'static Stage2VerifierProgramPlan,
     ) -> Result<(), VerifyStage2Error> {
         self.0
-            .evaluate_available_field_exprs(program.field_exprs, evaluate_stage2_field_expr)
+            .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
+            .map_err(VerifyStage2Error::from)
     }
 
     fn scalar(&self, symbol: &'static str) -> Result<F, VerifyStage2Error> {
@@ -639,276 +703,58 @@ impl<F: Field> Stage2ValueStore<F> {
     }
 }
 
-fn evaluate_stage2_field_expr<F: Field>(
-    expr: &Stage2FieldExprPlan,
-    operands: &[F],
-) -> Result<F, VerifyStage2Error> {
-    match expr.formula {
-        "opening_eval" => Ok(single_operand(expr.symbol, operands)?),
-        "jolt_stage2_product_virtual_uniskip_input" => {
-            require_operand_count(expr.symbol, 4, operands.len())?;
-            let weights = lagrange_evals(
-                PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START,
-                PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE,
-                operands[0],
-            );
-            Ok(weights[0] * operands[1] + weights[1] * operands[2] + weights[2] * operands[3])
-        }
-        "jolt_stage2_ram_read_write_input" => {
-            require_operand_count(expr.symbol, 3, operands.len())?;
-            Ok(operands[1] + operands[0] * operands[2])
-        }
-        "jolt_stage2_instruction_lookup_input" => {
-            require_operand_count(expr.symbol, 6, operands.len())?;
-            let gamma = operands[0];
-            let gamma2 = gamma.square();
-            let gamma3 = gamma2 * gamma;
-            let gamma4 = gamma2.square();
-            Ok(operands[1]
-                + gamma * operands[2]
-                + gamma2 * operands[3]
-                + gamma3 * operands[4]
-                + gamma4 * operands[5])
-        }
-        "field.add" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] + operands[1])
-        }
-        "field.sub" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] - operands[1])
-        }
-        "field.mul" => {
-            require_operand_count(expr.symbol, 2, operands.len())?;
-            Ok(operands[0] * operands[1])
-        }
-        "field.neg" => {
-            require_operand_count(expr.symbol, 1, operands.len())?;
-            Ok(-operands[0])
-        }
-        formula => {
-            if let Some(exponent) = formula.strip_prefix("field.pow:") {
-                require_operand_count(expr.symbol, 1, operands.len())?;
-                let exponent = exponent.parse::<usize>().map_err(|_| {
-                    VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                return Ok(pow_field(operands[0], exponent));
-            }
-            if let Some(spec) = formula.strip_prefix("poly.lagrange_basis_eval:") {
-                require_operand_count(expr.symbol, 1, operands.len())?;
-                let parts = spec.split(':').collect::<Vec<_>>();
-                if parts.len() != 3 {
-                    return Err(VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    });
-                }
-                let domain_start = parts[0].parse::<i64>().map_err(|_| {
-                    VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                let domain_size = parts[1].parse::<usize>().map_err(|_| {
-                    VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                let index = parts[2].parse::<usize>().map_err(|_| {
-                    VerifyStage2Error::UnsupportedFieldExpr {
-                        symbol: expr.symbol,
-                        formula,
-                    }
-                })?;
-                let weights = lagrange_evals(domain_start, domain_size, operands[0]);
-                return weights
-                    .get(index)
-                    .copied()
-                    .ok_or(VerifyStage2Error::InvalidInputLength {
-                        input: expr.symbol,
-                        expected: index + 1,
-                        actual: weights.len(),
-                    });
-            }
-            Err(VerifyStage2Error::UnsupportedFieldExpr {
-                symbol: expr.symbol,
-                formula,
-            })
-        }
-    }
-}
-
-fn expected_batched_output_claim(
-    program: &'static Stage2VerifierProgramPlan,
-    driver: &'static Stage2SumcheckDriverPlan,
+fn stage2_relation_output_inputs<'a>(
     store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
     ram: Option<&Stage2RamData<'_>>,
-) -> Result<Fr, VerifyStage2Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage2Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage2Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let value = match instance.relation {
-            "jolt.stage2.ram.read_write" => expected_ram_read_write(store, evals, local_point)?,
-            "jolt.stage2.product_virtual.remainder" => {
-                expected_product_remainder(store, evals, local_point)?
-            }
-            "jolt.stage2.instruction_lookup.claim_reduction" => {
-                expected_instruction_lookup(store, evals, local_point)?
-            }
-            "jolt.stage2.ram.raf_evaluation" => expected_ram_raf(evals, local_point, ram)?,
-            "jolt.stage2.ram.output_check" => expected_ram_output(store, evals, local_point, ram)?,
-            relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_ram_read_write(
-    store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage2Error> {
-    let r_cycle_stage1 = store.point("stage2.input.stage1.RamReadValue")?;
-    let log_t = r_cycle_stage1.len();
-    let r_cycle = reverse_slice(&local_point[..log_t]);
-    let eq_eval = EqPolynomial::<Fr>::mle(r_cycle_stage1, &r_cycle);
-    let gamma = store.scalar("stage2.ram_read_write.gamma")?;
-    let val = eval_by_name(evals, "stage2.ram_read_write.eval.RamVal")?;
-    let ra = eval_by_name(evals, "stage2.ram_read_write.eval.RamRa")?;
-    let inc = eval_by_name(evals, "stage2.ram_read_write.eval.RamInc")?;
-    Ok(eq_eval * ra * (val + gamma * (val + inc)))
-}
-
-fn expected_product_remainder(
-    store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage2Error> {
-    let tau_low = store.point("stage2.input.stage1.Product")?;
-    let tau_high = store.scalar("stage2.product_virtual.tau_high")?;
-    let r0 = *store
-        .point("stage2.product_virtual.uniskip.sumcheck")?
-        .first()
-        .ok_or(VerifyStage2Error::MissingValue {
-            symbol: "stage2.product_virtual.uniskip.sumcheck",
-        })?;
-    let r_tail = reverse_slice(local_point);
-    let low = EqPolynomial::<Fr>::mle(tau_low, &r_tail);
-    let high = lagrange_kernel_eval(
-        PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START,
-        PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE,
-        tau_high,
-        r0,
-    );
-    let weights = lagrange_evals(
-        PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START,
-        PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE,
-        r0,
-    );
-    let left = weights[0]
-        * eval_by_name(evals, "stage2.product_virtual.remainder.eval.LeftInstructionInput")?
-        + weights[1] * eval_by_name(evals, "stage2.product_virtual.remainder.eval.LookupOutput")?
-        + weights[2] * eval_by_name(evals, "stage2.product_virtual.remainder.eval.OpFlagJump")?;
-    let right = weights[0]
-        * eval_by_name(evals, "stage2.product_virtual.remainder.eval.RightInstructionInput")?
-        + weights[1]
-            * eval_by_name(evals, "stage2.product_virtual.remainder.eval.InstructionFlagBranch")?
-        + weights[2]
-            * (Fr::from_u64(1)
-                - eval_by_name(evals, "stage2.product_virtual.remainder.eval.NextIsNoop")?);
-    Ok(high * low * left * right)
-}
-
-fn expected_instruction_lookup(
-    store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage2Error> {
-    let opening_point = reverse_slice(local_point);
-    let r_spartan = store.point("stage2.input.stage1.LookupOutput")?;
-    let eq_eval = EqPolynomial::<Fr>::mle(&opening_point, r_spartan);
-    let gamma = store.scalar("stage2.instruction_lookup.gamma")?;
-    let gamma2 = gamma.square();
-    let gamma3 = gamma2 * gamma;
-    let gamma4 = gamma2.square();
-    let weighted = eval_by_name(
-        evals,
-        "stage2.instruction_lookup.claim_reduction.eval.LookupOutput",
-    )? + gamma
-        * eval_by_name(
-            evals,
-            "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand",
-        )?
-        + gamma2
-            * eval_by_name(
-                evals,
-                "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand",
-            )?
-        + gamma3
-            * eval_by_name(
-                evals,
-                "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput",
-            )?
-        + gamma4
-            * eval_by_name(
-                evals,
-                "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput",
-            )?;
-    Ok(eq_eval * weighted)
+    instance: &Stage2SumcheckInstanceResultPlan,
+    local_point: &'a [Fr],
+) -> Result<bolt_verifier_runtime::RelationOutputInputs<'a, Fr>, VerifyStage2Error> {
+    let scalars = match instance.relation {
+        Stage2RelationKind::Stage2RamRafEvaluation => stage2_ram_raf_output_scalars(local_point, ram)?,
+        Stage2RelationKind::Stage2RamOutputCheck => stage2_ram_output_scalars(store, local_point, ram)?,
+        _ => Vec::new(),
+    };
+    Ok(bolt_verifier_runtime::RelationOutputInputs {
+        scalars,
+        points: Vec::new(),
+    })
 }
 
-fn expected_ram_raf(
-    evals: &[Stage2NamedEval<Fr>],
+fn stage2_ram_raf_output_scalars(
     local_point: &[Fr],
     ram: Option<&Stage2RamData<'_>>,
-) -> Result<Fr, VerifyStage2Error> {
+) -> Result<Vec<bolt_verifier_runtime::NamedScalar<Fr>>, VerifyStage2Error> {
     let ram = ram.ok_or(VerifyStage2Error::MissingRam {
-        relation: "jolt.stage2.ram.raf_evaluation",
+        context: "stage2.ram.raf_evaluation",
     })?;
     let address = reverse_slice(local_point);
-    let unmap = unmap_eval(ram.log_k, ram.start_address, &address);
-    Ok(unmap * eval_by_name(evals, "stage2.ram_raf.eval.RamRa")?)
+    Ok(vec![bolt_verifier_runtime::NamedScalar {
+        symbol: "stage2.ram_raf.output.unmap",
+        value: unmap_eval(ram.log_k, ram.start_address, &address),
+    }])
 }
 
-fn expected_ram_output(
+fn stage2_ram_output_scalars(
     store: &Stage2ValueStore<Fr>,
-    evals: &[Stage2NamedEval<Fr>],
     local_point: &[Fr],
     ram: Option<&Stage2RamData<'_>>,
-) -> Result<Fr, VerifyStage2Error> {
+) -> Result<Vec<bolt_verifier_runtime::NamedScalar<Fr>>, VerifyStage2Error> {
     let ram = ram.ok_or(VerifyStage2Error::MissingRam {
-        relation: "jolt.stage2.ram.output_check",
+        context: "stage2.ram.output_check",
     })?;
     let layout = ram.output_layout.ok_or(VerifyStage2Error::MissingRam {
-        relation: "jolt.stage2.ram.output_check.layout",
+        context: "stage2.ram.output_check.layout",
     })?;
     let r_address = store.point("stage2.ram_output.r_address")?;
     let opening_point = reverse_slice(local_point);
-    let eq_eval = EqPolynomial::<Fr>::mle(r_address, &opening_point);
+    if r_address.len() != opening_point.len() {
+        return Err(VerifyStage2Error::InvalidInputLength {
+            input: "stage2.ram_output.r_address",
+            expected: opening_point.len(),
+            actual: r_address.len(),
+        });
+    }
+    let eq_eval = eq_eval(r_address, &opening_point);
     let io_mask = range_mask_eval(layout.io_start, layout.io_end, &opening_point);
     let val_io = sparse_final_ram_eval(
         ram.final_ram,
@@ -916,8 +762,26 @@ fn expected_ram_output(
         layout.io_end,
         &opening_point,
     );
-    let val_final = eval_by_name(evals, "stage2.ram_output.eval.RamValFinal")?;
-    Ok(eq_eval * io_mask * (val_final - val_io))
+    Ok(vec![
+        bolt_verifier_runtime::NamedScalar {
+            symbol: "stage2.ram_output.output.eq",
+            value: eq_eval,
+        },
+        bolt_verifier_runtime::NamedScalar {
+            symbol: "stage2.ram_output.output.io_mask",
+            value: io_mask,
+        },
+        bolt_verifier_runtime::NamedScalar {
+            symbol: "stage2.ram_output.output.val_io",
+            value: val_io,
+        },
+    ])
+}
+
+fn eq_eval(lhs: &[Fr], rhs: &[Fr]) -> Fr {
+    lhs.iter().zip(rhs).fold(Fr::from_u64(1), |acc, (lhs, rhs)| {
+        acc * (*lhs * *rhs + (Fr::from_u64(1) - *lhs) * (Fr::from_u64(1) - *rhs))
+    })
 }
 
 fn driver_evals(
diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs
index d22851483a..cda25b6582 100644
--- a/crates/jolt-verifier/src/stages/stage3.rs
+++ b/crates/jolt-verifier/src/stages/stage3.rs
@@ -1,33 +1,41 @@
 #![allow(dead_code)]
 
-use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};
+use bolt_verifier_runtime::find_plan;
 use jolt_field::{Field, Fr};
-use jolt_poly::{EqPlusOnePolynomial, EqPolynomial};
 use jolt_sumcheck::SumcheckError;
 use jolt_transcript::{Blake2bTranscript, Transcript};
 
 pub type DefaultStage3Transcript = Blake2bTranscript<Fr>;
 
-pub type Stage3NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage3SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage3ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage3ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage3Proof<F> = super::common::StageProof<F>;
-pub type Stage3OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-pub type Stage3VerifierProgramPlan = super::common::StageVerifierProgramPlan;
+pub type Stage3NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage3SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage3ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage3ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage3Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage3OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage3VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlan<Stage3RelationKind>;
+pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage3RelationKind>;
+pub type Stage3SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage3RelationKind>;
+pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage3RelationKind>;
+pub type Stage3RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage3RelationKind>;
 
-pub use super::common::{
-    FieldConstantPlan as Stage3FieldConstantPlan, FieldExprPlan as Stage3FieldExprPlan,
+pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage3ClaimKind, FieldConstantPlan as Stage3FieldConstantPlan,
+    FieldExprKind as Stage3FieldExprKind,
+    FieldExprPlan as Stage3FieldExprPlan,
+    ScalarExprKind as Stage3ScalarExprKind,
+    ScalarExprPlan as Stage3ScalarExprPlan,
     OpeningBatchPlan as Stage3OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan,
-    PointConcatPlan as Stage3PointConcatPlan, PointSlicePlan as Stage3PointSlicePlan,
-    ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params,
+    PointExprKind as Stage3PointExprKind, PointExprPlan as Stage3PointExprPlan,
+    OpeningEqualityMode as Stage3OpeningEqualityMode,
+    ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan,
+    StageParams as Stage3Params,
     SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage3SumcheckInstanceResultPlan,
+    TranscriptSqueezeKind as Stage3TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage3TranscriptSqueezePlan,
-    SumcheckClaimPlan as Stage3SumcheckClaimPlan,
-    SumcheckDriverPlan as Stage3SumcheckDriverPlan,
 };
 
 #[derive(Debug)]
@@ -39,44 +47,39 @@ pub enum VerifyStage3Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage3RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error);
 
-pub const STAGE3_PARAMS: Stage3Params = Stage3Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE3_PARAMS: Stage3Params = Stage3Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[
-    Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.spartan_shift.gamma" },
-    Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.instruction_input.gamma" },
-    Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.registers.gamma" },
-    Stage3ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage3.sumcheck" },
+    Stage3ProgramStepPlan { kind: Stage3ProgramStepKind::TranscriptSqueeze, symbol: "stage3.spartan_shift.gamma" },
+    Stage3ProgramStepPlan { kind: Stage3ProgramStepKind::TranscriptSqueeze, symbol: "stage3.instruction_input.gamma" },
+    Stage3ProgramStepPlan { kind: Stage3ProgramStepKind::TranscriptSqueeze, symbol: "stage3.registers.gamma" },
+    Stage3ProgramStepPlan { kind: Stage3ProgramStepKind::SumcheckDriver, symbol: "stage3.sumcheck" },
 ];
 
 pub const STAGE3_TRANSCRIPT_SQUEEZES: &[Stage3TranscriptSqueezePlan] = &[
-    Stage3TranscriptSqueezePlan { symbol: "stage3.spartan_shift.gamma", label: "spartan_shift_gamma", kind: "challenge_scalar", count: 1 },
-    Stage3TranscriptSqueezePlan { symbol: "stage3.instruction_input.gamma", label: "instruction_input_gamma", kind: "challenge_scalar", count: 1 },
-    Stage3TranscriptSqueezePlan { symbol: "stage3.registers.gamma", label: "registers_gamma", kind: "challenge_scalar", count: 1 },
+    Stage3TranscriptSqueezePlan { symbol: "stage3.spartan_shift.gamma", label: "spartan_shift_gamma", kind: Stage3TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage3TranscriptSqueezePlan { symbol: "stage3.instruction_input.gamma", label: "instruction_input_gamma", kind: Stage3TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage3TranscriptSqueezePlan { symbol: "stage3.registers.gamma", label: "registers_gamma", kind: Stage3TranscriptSqueezeKind::ChallengeScalar, count: 1 },
 ];
 
 pub const STAGE3_OPENING_INPUTS: &[Stage3OpeningInputPlan] = &[
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextUnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextUnexpandedPC", oracle: "NextUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextPC", oracle: "NextPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextIsVirtual", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextIsVirtual", oracle: "NextIsVirtual", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextIsFirstInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextIsFirstInSequence", oracle: "NextIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.NextIsNoop", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.NextIsNoop", oracle: "NextIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.LeftInstructionInput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.RightInstructionInput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.instruction_lookup.LeftInstructionInput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.instruction_lookup.RightInstructionInput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.RdWriteValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.Rs1Value", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.Rs2Value", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextUnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextUnexpandedPC", oracle: "NextUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextPC", oracle: "NextPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextIsVirtual", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextIsVirtual", oracle: "NextIsVirtual", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextIsFirstInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextIsFirstInSequence", oracle: "NextIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.NextIsNoop", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.NextIsNoop", oracle: "NextIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.LeftInstructionInput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.RightInstructionInput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.instruction_lookup.LeftInstructionInput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage2.instruction_lookup.RightInstructionInput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.RdWriteValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.Rs1Value", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
+    Stage3OpeningInputPlan { symbol: "stage3.input.stage1.Rs2Value", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual },
 ];
 
 pub const STAGE3_FIELD_CONSTANTS: &[Stage3FieldConstantPlan] = &[
@@ -84,49 +87,76 @@ pub const STAGE3_FIELD_CONSTANTS: &[Stage3FieldConstantPlan] = &[
 ];
 
 pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma2", kind: "op", formula: "field.pow:2", operands: "stage3.spartan_shift.gamma" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma3", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma2|stage3.spartan_shift.gamma" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma4", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma2|stage3.spartan_shift.gamma2" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextPC", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma|stage3.input.stage1.NextPC" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsVirtual", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma2|stage3.input.stage1.NextIsVirtual" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsFirstInSequence", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma3|stage3.input.stage1.NextIsFirstInSequence" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.one_minus.NextIsNoop", kind: "op", formula: "field.sub", operands: "stage3.field.one|stage3.input.stage2.product_virtual.NextIsNoop" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsNoop", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma4|stage3.spartan_shift.one_minus.NextIsNoop" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC", kind: "op", formula: "field.add", operands: "stage3.input.stage1.NextUnexpandedPC|stage3.spartan_shift.term.NextPC" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsVirtual", kind: "op", formula: "field.add", operands: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC|stage3.spartan_shift.term.NextIsVirtual" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsFirstInSequence", kind: "op", formula: "field.add", operands: "stage3.spartan_shift.partial.NextIsVirtual|stage3.spartan_shift.term.NextIsFirstInSequence" },
-    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.claim_expr", kind: "op", formula: "field.add", operands: "stage3.spartan_shift.partial.NextIsFirstInSequence|stage3.spartan_shift.term.NextIsNoop" },
-    Stage3FieldExprPlan { symbol: "stage3.instruction_input.term.LeftInstructionInput", kind: "op", formula: "field.mul", operands: "stage3.instruction_input.gamma|stage3.input.stage2.product_virtual.LeftInstructionInput" },
-    Stage3FieldExprPlan { symbol: "stage3.instruction_input.claim_expr", kind: "op", formula: "field.add", operands: "stage3.input.stage2.product_virtual.RightInstructionInput|stage3.instruction_input.term.LeftInstructionInput" },
-    Stage3FieldExprPlan { symbol: "stage3.registers.gamma2", kind: "op", formula: "field.pow:2", operands: "stage3.registers.gamma" },
-    Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs1Value", kind: "op", formula: "field.mul", operands: "stage3.registers.gamma|stage3.input.stage1.Rs1Value" },
-    Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs2Value", kind: "op", formula: "field.mul", operands: "stage3.registers.gamma2|stage3.input.stage1.Rs2Value" },
-    Stage3FieldExprPlan { symbol: "stage3.registers.partial.RdWriteValueRs1Value", kind: "op", formula: "field.add", operands: "stage3.input.stage1.RdWriteValue|stage3.registers.term.Rs1Value" },
-    Stage3FieldExprPlan { symbol: "stage3.registers.claim_expr", kind: "op", formula: "field.add", operands: "stage3.registers.partial.RdWriteValueRs1Value|stage3.registers.term.Rs2Value" },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma2", kind: Stage3FieldExprKind::Pow(2), operands: &["stage3.spartan_shift.gamma"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma3", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma2", "stage3.spartan_shift.gamma"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma4", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma2", "stage3.spartan_shift.gamma2"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextPC", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma", "stage3.input.stage1.NextPC"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsVirtual", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma2", "stage3.input.stage1.NextIsVirtual"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsFirstInSequence", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma3", "stage3.input.stage1.NextIsFirstInSequence"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.one_minus.NextIsNoop", kind: Stage3FieldExprKind::Sub, operands: &["stage3.field.one", "stage3.input.stage2.product_virtual.NextIsNoop"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsNoop", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma4", "stage3.spartan_shift.one_minus.NextIsNoop"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC", kind: Stage3FieldExprKind::Add, operands: &["stage3.input.stage1.NextUnexpandedPC", "stage3.spartan_shift.term.NextPC"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsVirtual", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.partial.NextUnexpandedPCNextPC", "stage3.spartan_shift.term.NextIsVirtual"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsFirstInSequence", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.partial.NextIsVirtual", "stage3.spartan_shift.term.NextIsFirstInSequence"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.partial.NextIsFirstInSequence", "stage3.spartan_shift.term.NextIsNoop"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.term.LeftInstructionInput", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.gamma", "stage3.input.stage2.product_virtual.LeftInstructionInput"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.input.stage2.product_virtual.RightInstructionInput", "stage3.instruction_input.term.LeftInstructionInput"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.gamma2", kind: Stage3FieldExprKind::Pow(2), operands: &["stage3.registers.gamma"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs1Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.gamma", "stage3.input.stage1.Rs1Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs2Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.gamma2", "stage3.input.stage1.Rs2Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.partial.RdWriteValueRs1Value", kind: Stage3FieldExprKind::Add, operands: &["stage3.input.stage1.RdWriteValue", "stage3.registers.term.Rs1Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers.partial.RdWriteValueRs1Value", "stage3.registers.term.Rs2Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.term.PC", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma", "stage3.spartan_shift.eval.PC"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma2", "stage3.spartan_shift.eval.OpFlagVirtualInstruction"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma3", "stage3.spartan_shift.eval.OpFlagIsFirstInSequence"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", kind: Stage3FieldExprKind::Sub, operands: &["stage3.field.one", "stage3.spartan_shift.eval.InstructionFlagIsNoop"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.partial.PC", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.eval.UnexpandedPC", "stage3.spartan_shift.output.term.PC"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.output.partial.PC", "stage3.spartan_shift.output.term.OpFlagVirtualInstruction"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.weighted_outer", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.outer", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.output.eq.NextPC", "stage3.spartan_shift.output.weighted_outer"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.noop_product", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.output.eq.NextIsNoop", "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.noop_term", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma4", "stage3.spartan_shift.output.noop_product"] },
+    Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.output.outer", "stage3.spartan_shift.output.noop_term"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.left.term.Rs1Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.eval.Rs1Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.left.term.PC", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.eval.UnexpandedPC"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.left", kind: Stage3FieldExprKind::Add, operands: &["stage3.instruction_input.output.left.term.Rs1Value", "stage3.instruction_input.output.left.term.PC"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.right.term.Rs2Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.eval.Rs2Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.right.term.Imm", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", "stage3.instruction_input.eval.Imm"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.right", kind: Stage3FieldExprKind::Add, operands: &["stage3.instruction_input.output.right.term.Rs2Value", "stage3.instruction_input.output.right.term.Imm"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.left_weighted", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.gamma", "stage3.instruction_input.output.left"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.weighted_inputs", kind: Stage3FieldExprKind::Add, operands: &["stage3.instruction_input.output.right", "stage3.instruction_input.output.left_weighted"] },
+    Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.claim_expr", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.output.eq.LeftInstructionInput", "stage3.instruction_input.output.weighted_inputs"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.output.term.Rs1Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.gamma", "stage3.registers_claim_reduction.eval.Rs1Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.output.term.Rs2Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.gamma2", "stage3.registers_claim_reduction.eval.Rs2Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.output.partial.RdWriteValueRs1Value", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers_claim_reduction.eval.RdWriteValue", "stage3.registers.output.term.Rs1Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.output.weighted_register_values", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers.output.partial.RdWriteValueRs1Value", "stage3.registers.output.term.Rs2Value"] },
+    Stage3FieldExprPlan { symbol: "stage3.registers.output.claim_expr", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.output.eq.RdWriteValue", "stage3.registers.output.weighted_register_values"] },
 ];
-pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[
-    Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some("jolt.stage3.spartan_shift"), claim_value: "stage3.spartan_shift.claim_expr", input_openings: "stage3.input.stage1.NextUnexpandedPC|stage3.input.stage1.NextPC|stage3.input.stage1.NextIsVirtual|stage3.input.stage1.NextIsFirstInSequence|stage3.input.stage2.product_virtual.NextIsNoop" },
-    Stage3SumcheckClaimPlan { symbol: "stage3.instruction_input.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage3.instruction_input.weighted_inputs", kernel: None, relation: Some("jolt.stage3.instruction_input"), claim_value: "stage3.instruction_input.claim_expr", input_openings: "stage3.input.stage2.product_virtual.RightInstructionInput|stage3.input.stage2.product_virtual.LeftInstructionInput" },
-    Stage3SumcheckClaimPlan { symbol: "stage3.registers_claim_reduction.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.registers.weighted_register_values", kernel: None, relation: Some("jolt.stage3.registers_claim_reduction"), claim_value: "stage3.registers.claim_expr", input_openings: "stage3.input.stage1.RdWriteValue|stage3.input.stage1.Rs1Value|stage3.input.stage1.Rs2Value" },
+pub const STAGE3_SCALAR_EXPRS: &[Stage3ScalarExprPlan] = &[
+    Stage3ScalarExprPlan { symbol: "stage3.spartan_shift.output.eq.NextPC", kind: Stage3ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.spartan_shift.instance", "stage3.input.stage1.NextPC"] },
+    Stage3ScalarExprPlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", kind: Stage3ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.spartan_shift.instance", "stage3.input.stage2.product_virtual.NextIsNoop"] },
+    Stage3ScalarExprPlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", kind: Stage3ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.instruction_input.instance", "stage3.input.stage2.product_virtual.LeftInstructionInput"] },
+    Stage3ScalarExprPlan { symbol: "stage3.registers.output.eq.RdWriteValue", kind: Stage3ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.registers_claim_reduction.instance", "stage3.input.stage1.RdWriteValue"] },
 ];
-pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    16,
+pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[
+    Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr" },
+    Stage3SumcheckClaimPlan { symbol: "stage3.instruction_input.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage3.instruction_input.weighted_inputs", kernel: None, relation: Some(Stage3RelationKind::Stage3InstructionInput), claim_value: "stage3.instruction_input.claim_expr" },
+    Stage3SumcheckClaimPlan { symbol: "stage3.registers_claim_reduction.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.registers.weighted_register_values", kernel: None, relation: Some(Stage3RelationKind::Stage3RegistersClaimReduction), claim_value: "stage3.registers.claim_expr" },
 ];
+pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16];
 
 pub const STAGE3_SUMCHECK_BATCHES: &[Stage3SumcheckBatchPlan] = &[
-    Stage3SumcheckBatchPlan { symbol: "stage3.batch", stage: "stage3", proof_slot: "stage3.sumcheck", policy: "jolt_core_stage3_aligned", count: 3, ordered_claims: "stage3.spartan_shift.input|stage3.instruction_input.input|stage3.registers_claim_reduction.input", claim_operands: "stage3.spartan_shift.input|stage3.instruction_input.input|stage3.registers_claim_reduction.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
-];
-pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    16,
+    Stage3SumcheckBatchPlan { symbol: "stage3.batch", stage: "stage3", proof_slot: "stage3.sumcheck", policy: "jolt_core_stage3_aligned", count: 3, claim_operands: &["stage3.spartan_shift.input", "stage3.instruction_input.input", "stage3.registers_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
+pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16];
 
 pub const STAGE3_SUMCHECK_DRIVERS: &[Stage3SumcheckDriverPlan] = &[
-    Stage3SumcheckDriverPlan { symbol: "stage3.sumcheck", stage: "stage3", proof_slot: "stage3.sumcheck", kernel: None, relation: Some("jolt.stage3.batched"), batch: "stage3.batch", policy: "jolt_core_stage3_aligned", round_schedule: STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 16, degree: 3 },
+    Stage3SumcheckDriverPlan { symbol: "stage3.sumcheck", stage: "stage3", proof_slot: "stage3.sumcheck", kernel: None, relation: Some(Stage3RelationKind::Stage3Batched), batch: "stage3.batch", policy: "jolt_core_stage3_aligned", round_schedule: STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 16, degree: 3 },
 ];
 pub const STAGE3_SUMCHECK_INSTANCE_RESULTS: &[Stage3SumcheckInstanceResultPlan] = &[
-    Stage3SumcheckInstanceResultPlan { symbol: "stage3.spartan_shift.instance", source: "stage3.sumcheck", claim: "stage3.spartan_shift.input", relation: "jolt.stage3.spartan_shift", index: 0, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 2 },
-    Stage3SumcheckInstanceResultPlan { symbol: "stage3.instruction_input.instance", source: "stage3.sumcheck", claim: "stage3.instruction_input.input", relation: "jolt.stage3.instruction_input", index: 1, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 3 },
-    Stage3SumcheckInstanceResultPlan { symbol: "stage3.registers_claim_reduction.instance", source: "stage3.sumcheck", claim: "stage3.registers_claim_reduction.input", relation: "jolt.stage3.registers_claim_reduction", index: 2, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 2 },
+    Stage3SumcheckInstanceResultPlan { symbol: "stage3.spartan_shift.instance", source: "stage3.sumcheck", claim: "stage3.spartan_shift.input", relation: Stage3RelationKind::Stage3SpartanShift, index: 0, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 },
+    Stage3SumcheckInstanceResultPlan { symbol: "stage3.instruction_input.instance", source: "stage3.sumcheck", claim: "stage3.instruction_input.input", relation: Stage3RelationKind::Stage3InstructionInput, index: 1, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 },
+    Stage3SumcheckInstanceResultPlan { symbol: "stage3.registers_claim_reduction.instance", source: "stage3.sumcheck", claim: "stage3.registers_claim_reduction.input", relation: Stage3RelationKind::Stage3RegistersClaimReduction, index: 2, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 },
 ];
 
 pub const STAGE3_SUMCHECK_EVALS: &[Stage3SumcheckEvalPlan] = &[
@@ -148,40 +178,43 @@ pub const STAGE3_SUMCHECK_EVALS: &[Stage3SumcheckEvalPlan] = &[
     Stage3SumcheckEvalPlan { symbol: "stage3.registers_claim_reduction.eval.Rs2Value", source: "stage3.sumcheck", name: "stage3.registers_claim_reduction.eval.Rs2Value", index: 15, oracle: "Rs2Value" },
 ];
 
-pub const STAGE3_POINT_SLICES: &[Stage3PointSlicePlan] = &[
+pub const STAGE3_POINT_EXPRS: &[Stage3PointExprPlan] = &[
 
 ];
 
-pub const STAGE3_POINT_CONCATS: &[Stage3PointConcatPlan] = &[
-
-];
 pub const STAGE3_OPENING_CLAIMS: &[Stage3OpeningClaimPlan] = &[
-    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.UnexpandedPC" },
-    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.PC" },
-    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.OpFlagVirtualInstruction" },
-    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.OpFlagIsFirstInSequence" },
-    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.InstructionFlagIsNoop", oracle: "InstructionFlagIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.InstructionFlagIsNoop" },
-    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", oracle: "InstructionFlagLeftOperandIsRs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value" },
-    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Rs1Value" },
-    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", oracle: "InstructionFlagLeftOperandIsPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC" },
-    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.UnexpandedPC" },
-    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", oracle: "InstructionFlagRightOperandIsRs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value" },
-    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Rs2Value" },
-    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", oracle: "InstructionFlagRightOperandIsImm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm" },
-    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Imm" },
-    Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.RdWriteValue" },
-    Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.Rs1Value" },
-    Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.Rs2Value" },
+    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.UnexpandedPC" },
+    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.PC" },
+    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.OpFlagVirtualInstruction" },
+    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.OpFlagIsFirstInSequence" },
+    Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.InstructionFlagIsNoop", oracle: "InstructionFlagIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.InstructionFlagIsNoop" },
+    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", oracle: "InstructionFlagLeftOperandIsRs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value" },
+    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Rs1Value" },
+    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", oracle: "InstructionFlagLeftOperandIsPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC" },
+    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.UnexpandedPC" },
+    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", oracle: "InstructionFlagRightOperandIsRs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value" },
+    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Rs2Value" },
+    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", oracle: "InstructionFlagRightOperandIsImm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm" },
+    Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Imm" },
+    Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.RdWriteValue" },
+    Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.Rs1Value" },
+    Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.Rs2Value" },
 ];
 
 pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[
-    Stage3OpeningClaimEqualityPlan { symbol: "stage3.instruction_input.left_claim_consistency", mode: "point_and_eval", lhs: "stage3.input.stage2.product_virtual.LeftInstructionInput", rhs: "stage3.input.stage2.instruction_lookup.LeftInstructionInput" },
-    Stage3OpeningClaimEqualityPlan { symbol: "stage3.instruction_input.right_claim_consistency", mode: "point_and_eval", lhs: "stage3.input.stage2.product_virtual.RightInstructionInput", rhs: "stage3.input.stage2.instruction_lookup.RightInstructionInput" },
+    Stage3OpeningClaimEqualityPlan { symbol: "stage3.instruction_input.left_claim_consistency", mode: Stage3OpeningEqualityMode::PointAndEval, lhs: "stage3.input.stage2.product_virtual.LeftInstructionInput", rhs: "stage3.input.stage2.instruction_lookup.LeftInstructionInput" },
+    Stage3OpeningClaimEqualityPlan { symbol: "stage3.instruction_input.right_claim_consistency", mode: Stage3OpeningEqualityMode::PointAndEval, lhs: "stage3.input.stage2.product_virtual.RightInstructionInput", rhs: "stage3.input.stage2.instruction_lookup.RightInstructionInput" },
 ];
 
 pub const STAGE3_OPENING_BATCHES: &[Stage3OpeningBatchPlan] = &[
-    Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: "stage3.spartan_shift.opening.UnexpandedPC|stage3.spartan_shift.opening.PC|stage3.spartan_shift.opening.OpFlagVirtualInstruction|stage3.spartan_shift.opening.OpFlagIsFirstInSequence|stage3.spartan_shift.opening.InstructionFlagIsNoop|stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value|stage3.instruction_input.opening.Rs1Value|stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC|stage3.instruction_input.opening.UnexpandedPC|stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value|stage3.instruction_input.opening.Rs2Value|stage3.instruction_input.opening.InstructionFlagRightOperandIsImm|stage3.instruction_input.opening.Imm|stage3.registers_claim_reduction.opening.RdWriteValue|stage3.registers_claim_reduction.opening.Rs1Value|stage3.registers_claim_reduction.opening.Rs2Value", claim_operands: "stage3.spartan_shift.opening.UnexpandedPC|stage3.spartan_shift.opening.PC|stage3.spartan_shift.opening.OpFlagVirtualInstruction|stage3.spartan_shift.opening.OpFlagIsFirstInSequence|stage3.spartan_shift.opening.InstructionFlagIsNoop|stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value|stage3.instruction_input.opening.Rs1Value|stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC|stage3.instruction_input.opening.UnexpandedPC|stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value|stage3.instruction_input.opening.Rs2Value|stage3.instruction_input.opening.InstructionFlagRightOperandIsImm|stage3.instruction_input.opening.Imm|stage3.registers_claim_reduction.opening.RdWriteValue|stage3.registers_claim_reduction.opening.Rs1Value|stage3.registers_claim_reduction.opening.Rs2Value" },
+    Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"], claim_operands: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"] },
+];
+pub const STAGE3_RELATION_OUTPUTS: &[Stage3RelationOutputPlan] = &[
+    Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" },
+    Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" },
+    Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" },
 ];
+
 pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan {
     params: STAGE3_PARAMS,
     steps: STAGE3_PROGRAM_STEPS,
@@ -189,13 +222,14 @@ pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan
     opening_inputs: STAGE3_OPENING_INPUTS,
     field_constants: STAGE3_FIELD_CONSTANTS,
     field_exprs: STAGE3_FIELD_EXPRS,
+    scalar_exprs: STAGE3_SCALAR_EXPRS,
     claims: STAGE3_SUMCHECK_CLAIMS,
     batches: STAGE3_SUMCHECK_BATCHES,
     drivers: STAGE3_SUMCHECK_DRIVERS,
     instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS,
     evals: STAGE3_SUMCHECK_EVALS,
-    point_slices: STAGE3_POINT_SLICES,
-    point_concats: STAGE3_POINT_CONCATS,
+    relation_outputs: STAGE3_RELATION_OUTPUTS,
+    point_exprs: STAGE3_POINT_EXPRS,
     opening_claims: STAGE3_OPENING_CLAIMS,
     opening_equalities: STAGE3_OPENING_EQUALITIES,
     opening_batches: STAGE3_OPENING_BATCHES,
@@ -228,26 +262,26 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
     let mut artifacts = Stage3ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage3ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage3Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage3_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "sumcheck_driver" => {
+            Stage3ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage3Error::MissingProof {
                         driver: step.symbol,
                     })?;
                 verify_stage3_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?;
             }
-            _ => {
+            Stage3ProgramStepKind::TranscriptAbsorbBytes => {
                 return Err(VerifyStage3Error::InvalidProof {
                     driver: step.symbol,
                     reason: "unsupported stage3 program step",
@@ -268,7 +302,7 @@ pub fn stage3_verifier_program() -> &'static Stage3VerifierProgramPlan {
 fn verify_stage3_squeeze<T>(
     program: &'static Stage3VerifierProgramPlan,
     squeeze: &'static Stage3TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage3ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage3Error>
@@ -284,7 +318,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage3Error::from)?;
     artifacts.challenge_vectors.push(Stage3ChallengeVector {
         symbol: squeeze.symbol,
@@ -297,7 +331,7 @@ fn verify_stage3_driver<T>(
     program: &'static Stage3VerifierProgramPlan,
     driver: &'static Stage3SumcheckDriverPlan,
     proof: &Stage3Proof<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage3ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage3Error>
@@ -310,16 +344,17 @@ where
         .ok_or(VerifyStage3Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage3Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage3.batched" => {
+        Stage3RelationKind::Stage3Batched => {
             verify_batched_stage3(program, driver, proof, store, transcript)?
         }
-        _ => {
-            return Err(VerifyStage3Error::UnsupportedRelation {
-                relation,
-            });
-        }
+        relation => return Err(VerifyStage3Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -329,25 +364,48 @@ fn verify_batched_stage3<T>(
     program: &'static Stage3VerifierProgramPlan,
     driver: &'static Stage3SumcheckDriverPlan,
     proof: &Stage3SumcheckOutput<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage3SumcheckOutput<Fr>, VerifyStage3Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage3Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs)
+            bolt_verifier_runtime::evaluate_relation_output_batch(
+                driver,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                &[],
+                store,
+                evals,
+                point,
+                batching_coeffs,
+                |_, _, _| Ok::<_, VerifyStage3Error>(bolt_verifier_runtime::RelationOutputInputs::empty()),
+            )
         },
         |store, verified| observe_stage3_sumcheck_output(program, store, verified),
         |driver, error| VerifyStage3Error::Sumcheck { driver, error },
@@ -356,7 +414,7 @@ where
 
 fn observe_stage3_sumcheck_output<F: Field>(
     program: &'static Stage3VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage3SumcheckOutput<F>,
 ) -> Result<(), VerifyStage3Error> {
     store.observe_sumcheck_output(
@@ -365,12 +423,12 @@ fn observe_stage3_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                _ => {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
                     return Err(VerifyStage3Error::InvalidProof {
                         driver: output.driver,
-                        reason: "unsupported point order",
+                        reason: "unsupported relation-local point order",
                     });
                 }
             }
@@ -384,8 +442,7 @@ fn observe_stage3_sumcheck_output<F: Field>(
         |symbol| VerifyStage3Error::MissingValue { symbol },
     )?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage3Error::InvalidInputLength {
             input,
             expected,
@@ -393,7 +450,7 @@ fn observe_stage3_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage3Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -401,126 +458,3 @@ fn observe_stage3_sumcheck_output<F: Field>(
         |symbol| VerifyStage3Error::MissingValue { symbol },
     )
 }
-
-fn expected_batched_output_claim(
-    program: &'static Stage3VerifierProgramPlan,
-    driver: &'static Stage3SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage3NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage3Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage3Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage3Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let value = match instance.relation {
-            "jolt.stage3.spartan_shift" => {
-                expected_spartan_shift(store, evals, local_point)?
-            }
-            "jolt.stage3.instruction_input" => {
-                expected_instruction_input(store, evals, local_point)?
-            }
-            "jolt.stage3.registers_claim_reduction" => {
-                expected_registers(store, evals, local_point)?
-            }
-            _ => {
-                return Err(VerifyStage3Error::UnsupportedRelation {
-                    relation: instance.relation,
-                });
-            }
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_spartan_shift(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage3NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage3Error> {
-    let opening_point = reverse_slice(local_point);
-    let eq_outer =
-        EqPlusOnePolynomial::<Fr>::new(super::common::store_point(store, "stage3.input.stage1.NextPC")?.to_vec())
-            .evaluate(&opening_point);
-    let eq_product = EqPlusOnePolynomial::<Fr>::new(
-        super::common::store_point(store, "stage3.input.stage2.product_virtual.NextIsNoop")?
-            .to_vec(),
-    )
-    .evaluate(&opening_point);
-    let weighted_outer = eval_by_name(evals, "stage3.spartan_shift.eval.UnexpandedPC")?
-        + super::common::store_scalar(store, "stage3.spartan_shift.gamma")?
-            * eval_by_name(evals, "stage3.spartan_shift.eval.PC")?
-        + super::common::store_scalar(store, "stage3.spartan_shift.gamma2")?
-            * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagVirtualInstruction")?
-        + super::common::store_scalar(store, "stage3.spartan_shift.gamma3")?
-            * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagIsFirstInSequence")?;
-    Ok(eq_outer * weighted_outer
-        + super::common::store_scalar(store, "stage3.spartan_shift.gamma4")?
-            * eq_product
-            * (Fr::from_u64(1)
-                - eval_by_name(evals, "stage3.spartan_shift.eval.InstructionFlagIsNoop")?))
-}
-
-fn expected_instruction_input(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage3NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage3Error> {
-    let opening_point = reverse_slice(local_point);
-    let eq_eval = EqPolynomial::<Fr>::mle(
-        &opening_point,
-        super::common::store_point(store, "stage3.input.stage2.product_virtual.LeftInstructionInput")?,
-    );
-    let left = eval_by_name(
-        evals,
-        "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value",
-    )? * eval_by_name(evals, "stage3.instruction_input.eval.Rs1Value")?
-        + eval_by_name(
-            evals,
-            "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC",
-        )? * eval_by_name(evals, "stage3.instruction_input.eval.UnexpandedPC")?;
-    let right = eval_by_name(
-        evals,
-        "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value",
-    )? * eval_by_name(evals, "stage3.instruction_input.eval.Rs2Value")?
-        + eval_by_name(
-            evals,
-            "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm",
-        )? * eval_by_name(evals, "stage3.instruction_input.eval.Imm")?;
-    Ok(eq_eval * (right + super::common::store_scalar(store, "stage3.instruction_input.gamma")? * left))
-}
-
-fn expected_registers(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage3NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage3Error> {
-    let opening_point = reverse_slice(local_point);
-    let eq_eval = EqPolynomial::<Fr>::mle(
-        &opening_point,
-        super::common::store_point(store, "stage3.input.stage1.RdWriteValue")?,
-    );
-    Ok(eq_eval
-        * (eval_by_name(evals, "stage3.registers_claim_reduction.eval.RdWriteValue")?
-            + super::common::store_scalar(store, "stage3.registers.gamma")?
-                * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs1Value")?
-            + super::common::store_scalar(store, "stage3.registers.gamma2")?
-                * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs2Value")?))
-}
diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs
index 3367e34d96..659b814916 100644
--- a/crates/jolt-verifier/src/stages/stage4.rs
+++ b/crates/jolt-verifier/src/stages/stage4.rs
@@ -1,31 +1,40 @@
 #![allow(dead_code)]
 
-use super::common::{batch_claims, eval_by_name, find_batch, find_plan, lt_polynomial_eval, reverse_slice};
+use bolt_verifier_runtime::find_plan;
 use jolt_field::{Field, Fr};
-use jolt_poly::EqPolynomial;
 use jolt_sumcheck::SumcheckError;
 use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};
 
-pub type Stage4NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage4SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage4ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage4ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage4Proof<F> = super::common::StageProof<F>;
-pub type Stage4OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-
-pub use super::common::{
-    FieldConstantPlan as Stage4FieldConstantPlan, FieldExprPlan as Stage4FieldExprPlan,
+pub type Stage4NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage4SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage4ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage4ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage4Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage4OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan<Stage4RelationKind>;
+pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage4RelationKind>;
+pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage4RelationKind>;
+pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage4RelationKind>;
+pub type Stage4RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage4RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage4ClaimKind, FieldConstantPlan as Stage4FieldConstantPlan,
+    FieldExprKind as Stage4FieldExprKind,
+    FieldExprPlan as Stage4FieldExprPlan,
+    ScalarExprKind as Stage4ScalarExprKind,
+    ScalarExprPlan as Stage4ScalarExprPlan,
     KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan,
-    PointConcatPlan as Stage4PointConcatPlan, PointSlicePlan as Stage4PointSlicePlan,
+    OpeningEqualityMode as Stage4OpeningEqualityMode, PointExprKind as Stage4PointExprKind,
+    PointExprPlan as Stage4PointExprPlan,
+    ProgramStepKind as Stage4ProgramStepKind,
     ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params,
-    StageProgramPlanNoPointZeros as Stage4CpuProgramPlan,
     SumcheckBatchPlan as Stage4SumcheckBatchPlan,
-    SumcheckClaimPlan as Stage4SumcheckClaimPlan, SumcheckDriverPlan as Stage4SumcheckDriverPlan,
     SumcheckEvalPlan as Stage4SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage4SumcheckInstanceResultPlan,
     TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan,
+    TranscriptSqueezeKind as Stage4TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage4TranscriptSqueezePlan,
 };
 
@@ -41,28 +50,23 @@ pub enum VerifyStage4Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage4RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error);
 
-pub const STAGE4_PARAMS: Stage4Params = Stage4Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE4_PARAMS: Stage4Params = Stage4Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE4_PROGRAM_STEPS: &[Stage4ProgramStepPlan] = &[
-    Stage4ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage4.registers_read_write.gamma" },
-    Stage4ProgramStepPlan { kind: "transcript_absorb_bytes", symbol: "stage4.ram_val_check.domain_separator" },
-    Stage4ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage4.ram_val_check.gamma" },
-    Stage4ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage4.sumcheck" },
+    Stage4ProgramStepPlan { kind: Stage4ProgramStepKind::TranscriptSqueeze, symbol: "stage4.registers_read_write.gamma" },
+    Stage4ProgramStepPlan { kind: Stage4ProgramStepKind::TranscriptAbsorbBytes, symbol: "stage4.ram_val_check.domain_separator" },
+    Stage4ProgramStepPlan { kind: Stage4ProgramStepKind::TranscriptSqueeze, symbol: "stage4.ram_val_check.gamma" },
+    Stage4ProgramStepPlan { kind: Stage4ProgramStepKind::SumcheckDriver, symbol: "stage4.sumcheck" },
 ];
 
 pub const STAGE4_TRANSCRIPT_SQUEEZES: &[Stage4TranscriptSqueezePlan] = &[
-    Stage4TranscriptSqueezePlan { symbol: "stage4.registers_read_write.gamma", label: "registers_read_write_gamma", kind: "challenge_scalar", count: 1 },
-    Stage4TranscriptSqueezePlan { symbol: "stage4.ram_val_check.gamma", label: "ram_val_check_gamma", kind: "challenge_scalar", count: 1 },
+    Stage4TranscriptSqueezePlan { symbol: "stage4.registers_read_write.gamma", label: "registers_read_write_gamma", kind: Stage4TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage4TranscriptSqueezePlan { symbol: "stage4.ram_val_check.gamma", label: "ram_val_check_gamma", kind: Stage4TranscriptSqueezeKind::ChallengeScalar, count: 1 },
 ];
 
 pub const STAGE4_TRANSCRIPT_ABSORB_BYTES: &[Stage4TranscriptAbsorbBytesPlan] = &[
@@ -70,14 +74,14 @@ pub const STAGE4_TRANSCRIPT_ABSORB_BYTES: &[Stage4TranscriptAbsorbBytesPlan] = &
 ];
 
 pub const STAGE4_OPENING_INPUTS: &[Stage4OpeningInputPlan] = &[
-    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.RdWriteValue", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.Rs1Value", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.Rs2Value", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.instruction.Rs1Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.instruction.Rs2Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage4OpeningInputPlan { symbol: "stage4.input.stage2.RamVal", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamVal", oracle: "RamVal", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage4OpeningInputPlan { symbol: "stage4.input.stage2.RamValFinal", source_stage: "stage2", source_claim: "stage2.ram_output.opening.RamValFinal", oracle: "RamValFinal", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage4OpeningInputPlan { symbol: "stage4.input.initial_ram.RamValInit", source_stage: "stage4_precomputed", source_claim: "stage4.ram_val_check.initial_ram_eval", oracle: "RamValInit", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: "virtual" },
+    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.RdWriteValue", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual },
+    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.Rs1Value", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual },
+    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.Rs2Value", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual },
+    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.instruction.Rs1Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual },
+    Stage4OpeningInputPlan { symbol: "stage4.input.stage3.instruction.Rs2Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual },
+    Stage4OpeningInputPlan { symbol: "stage4.input.stage2.RamVal", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamVal", oracle: "RamVal", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage4ClaimKind::Virtual },
+    Stage4OpeningInputPlan { symbol: "stage4.input.stage2.RamValFinal", source_stage: "stage2", source_claim: "stage2.ram_output.opening.RamValFinal", oracle: "RamValFinal", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual },
+    Stage4OpeningInputPlan { symbol: "stage4.input.initial_ram.RamValInit", source_stage: "stage4_precomputed", source_claim: "stage4.ram_val_check.initial_ram_eval", oracle: "RamValInit", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual },
 ];
 
 pub const STAGE4_FIELD_CONSTANTS: &[Stage4FieldConstantPlan] = &[
@@ -85,43 +89,53 @@ pub const STAGE4_FIELD_CONSTANTS: &[Stage4FieldConstantPlan] = &[
 ];
 
 pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[
-    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.gamma2", kind: "op", formula: "field.pow:2", operands: "stage4.registers_read_write.gamma" },
-    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs1Value", kind: "op", formula: "field.mul", operands: "stage4.registers_read_write.gamma|stage4.input.stage3.registers.Rs1Value" },
-    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs2Value", kind: "op", formula: "field.mul", operands: "stage4.registers_read_write.gamma2|stage4.input.stage3.registers.Rs2Value" },
-    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.partial.RdWriteValueRs1Value", kind: "op", formula: "field.add", operands: "stage4.input.stage3.registers.RdWriteValue|stage4.registers_read_write.term.Rs1Value" },
-    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.claim_expr", kind: "op", formula: "field.add", operands: "stage4.registers_read_write.partial.RdWriteValueRs1Value|stage4.registers_read_write.term.Rs2Value" },
-    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamVal", kind: "op", formula: "field.sub", operands: "stage4.input.stage2.RamVal|stage4.input.initial_ram.RamValInit" },
-    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamValFinal", kind: "op", formula: "field.sub", operands: "stage4.input.stage2.RamValFinal|stage4.input.initial_ram.RamValInit" },
-    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.term.RamValFinal", kind: "op", formula: "field.mul", operands: "stage4.ram_val_check.gamma|stage4.ram_val_check.delta.RamValFinal" },
-    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.claim_expr", kind: "op", formula: "field.add", operands: "stage4.ram_val_check.delta.RamVal|stage4.ram_val_check.term.RamValFinal" },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.gamma2", kind: Stage4FieldExprKind::Pow(2), operands: &["stage4.registers_read_write.gamma"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs1Value", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.gamma", "stage4.input.stage3.registers.Rs1Value"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs2Value", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.gamma2", "stage4.input.stage3.registers.Rs2Value"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.partial.RdWriteValueRs1Value", kind: Stage4FieldExprKind::Add, operands: &["stage4.input.stage3.registers.RdWriteValue", "stage4.registers_read_write.term.Rs1Value"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.claim_expr", kind: Stage4FieldExprKind::Add, operands: &["stage4.registers_read_write.partial.RdWriteValueRs1Value", "stage4.registers_read_write.term.Rs2Value"] },
+    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamVal", kind: Stage4FieldExprKind::Sub, operands: &["stage4.input.stage2.RamVal", "stage4.input.initial_ram.RamValInit"] },
+    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamValFinal", kind: Stage4FieldExprKind::Sub, operands: &["stage4.input.stage2.RamValFinal", "stage4.input.initial_ram.RamValInit"] },
+    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.term.RamValFinal", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.gamma", "stage4.ram_val_check.delta.RamValFinal"] },
+    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.claim_expr", kind: Stage4FieldExprKind::Add, operands: &["stage4.ram_val_check.delta.RamVal", "stage4.ram_val_check.term.RamValFinal"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.sum.RegistersValRdInc", kind: Stage4FieldExprKind::Add, operands: &["stage4.registers_read_write.eval.RegistersVal", "stage4.registers_read_write.eval.RdInc"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.term.RdWa", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.eval.RdWa", "stage4.registers_read_write.output.sum.RegistersValRdInc"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.term.Rs1Ra", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.eval.Rs1Ra", "stage4.registers_read_write.eval.RegistersVal"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.term.Rs2Ra", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.eval.Rs2Ra", "stage4.registers_read_write.eval.RegistersVal"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.weighted.Rs2Ra", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.gamma", "stage4.registers_read_write.output.term.Rs2Ra"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.read_terms", kind: Stage4FieldExprKind::Add, operands: &["stage4.registers_read_write.output.term.Rs1Ra", "stage4.registers_read_write.output.weighted.Rs2Ra"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.weighted.read_terms", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.gamma", "stage4.registers_read_write.output.read_terms"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.weighted_values", kind: Stage4FieldExprKind::Add, operands: &["stage4.registers_read_write.output.term.RdWa", "stage4.registers_read_write.output.weighted.read_terms"] },
+    Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.claim_expr", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.output.eq.RdWriteValue", "stage4.registers_read_write.output.weighted_values"] },
+    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.lt_plus_gamma", kind: Stage4FieldExprKind::Add, operands: &["stage4.ram_val_check.output.lt.RamValCycle", "stage4.ram_val_check.gamma"] },
+    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.term.RamIncRamRa", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.eval.RamInc", "stage4.ram_val_check.eval.RamRa"] },
+    Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.claim_expr", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.output.term.RamIncRamRa", "stage4.ram_val_check.output.lt_plus_gamma"] },
+];
+pub const STAGE4_SCALAR_EXPRS: &[Stage4ScalarExprPlan] = &[
+    Stage4ScalarExprPlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", kind: Stage4ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage4.registers_read_write.instance", "stage4.input.stage3.registers.RdWriteValue"] },
+    Stage4ScalarExprPlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", kind: Stage4ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Lt, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage4.ram_val_check.instance", "stage4.input.stage2.RamVal"] },
 ];
 pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[
 
 ];
 
 pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[
-    Stage4SumcheckClaimPlan { symbol: "stage4.registers_read_write.input", stage: "stage4", domain: "jolt.stage4_registers_rw_domain", num_rounds: 23, degree: 3, claim: "stage4.registers_read_write.weighted_values", kernel: None, relation: Some("jolt.stage4.registers_read_write"), claim_value: "stage4.registers_read_write.claim_expr", input_openings: "stage4.input.stage3.registers.RdWriteValue|stage4.input.stage3.registers.Rs1Value|stage4.input.stage3.registers.Rs2Value" },
-    Stage4SumcheckClaimPlan { symbol: "stage4.ram_val_check.input", stage: "stage4", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage4.ram_val_check.weighted_values", kernel: None, relation: Some("jolt.stage4.ram_val_check"), claim_value: "stage4.ram_val_check.claim_expr", input_openings: "stage4.input.stage2.RamVal|stage4.input.stage2.RamValFinal|stage4.input.initial_ram.RamValInit" },
-];
-pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    16,
-    7,
+    Stage4SumcheckClaimPlan { symbol: "stage4.registers_read_write.input", stage: "stage4", domain: "jolt.stage4_registers_rw_domain", num_rounds: 23, degree: 3, claim: "stage4.registers_read_write.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RegistersReadWrite), claim_value: "stage4.registers_read_write.claim_expr" },
+    Stage4SumcheckClaimPlan { symbol: "stage4.ram_val_check.input", stage: "stage4", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage4.ram_val_check.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RamValCheck), claim_value: "stage4.ram_val_check.claim_expr" },
 ];
+pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16, 7];
 
 pub const STAGE4_SUMCHECK_BATCHES: &[Stage4SumcheckBatchPlan] = &[
-    Stage4SumcheckBatchPlan { symbol: "stage4.batch", stage: "stage4", proof_slot: "stage4.sumcheck", policy: "jolt_core_stage4_aligned", count: 2, ordered_claims: "stage4.registers_read_write.input|stage4.ram_val_check.input", claim_operands: "stage4.registers_read_write.input|stage4.ram_val_check.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
-];
-pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    16,
-    7,
+    Stage4SumcheckBatchPlan { symbol: "stage4.batch", stage: "stage4", proof_slot: "stage4.sumcheck", policy: "jolt_core_stage4_aligned", count: 2, claim_operands: &["stage4.registers_read_write.input", "stage4.ram_val_check.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
+pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16, 7];
 
 pub const STAGE4_SUMCHECK_DRIVERS: &[Stage4SumcheckDriverPlan] = &[
-    Stage4SumcheckDriverPlan { symbol: "stage4.sumcheck", stage: "stage4", proof_slot: "stage4.sumcheck", kernel: None, relation: Some("jolt.stage4.batched"), batch: "stage4.batch", policy: "jolt_core_stage4_aligned", round_schedule: STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 23, degree: 3 },
+    Stage4SumcheckDriverPlan { symbol: "stage4.sumcheck", stage: "stage4", proof_slot: "stage4.sumcheck", kernel: None, relation: Some(Stage4RelationKind::Stage4Batched), batch: "stage4.batch", policy: "jolt_core_stage4_aligned", round_schedule: STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 23, degree: 3 },
 ];
 pub const STAGE4_SUMCHECK_INSTANCE_RESULTS: &[Stage4SumcheckInstanceResultPlan] = &[
-    Stage4SumcheckInstanceResultPlan { symbol: "stage4.registers_read_write.instance", source: "stage4.sumcheck", claim: "stage4.registers_read_write.input", relation: "jolt.stage4.registers_read_write", index: 0, point_arity: 23, num_rounds: 23, round_offset: 0, point_order: "stage4_registers_rw", degree: 3 },
-    Stage4SumcheckInstanceResultPlan { symbol: "stage4.ram_val_check.instance", source: "stage4.sumcheck", claim: "stage4.ram_val_check.input", relation: "jolt.stage4.ram_val_check", index: 1, point_arity: 16, num_rounds: 16, round_offset: 7, point_order: "reverse", degree: 3 },
+    Stage4SumcheckInstanceResultPlan { symbol: "stage4.registers_read_write.instance", source: "stage4.sumcheck", claim: "stage4.registers_read_write.input", relation: Stage4RelationKind::Stage4RegistersReadWrite, index: 0, point_arity: 23, num_rounds: 23, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::RelationLocal, degree: 3 },
+    Stage4SumcheckInstanceResultPlan { symbol: "stage4.ram_val_check.instance", source: "stage4.sumcheck", claim: "stage4.ram_val_check.input", relation: Stage4RelationKind::Stage4RamValCheck, index: 1, point_arity: 16, num_rounds: 16, round_offset: 7, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 },
 ];
 
 pub const STAGE4_SUMCHECK_EVALS: &[Stage4SumcheckEvalPlan] = &[
@@ -134,32 +148,35 @@ pub const STAGE4_SUMCHECK_EVALS: &[Stage4SumcheckEvalPlan] = &[
     Stage4SumcheckEvalPlan { symbol: "stage4.ram_val_check.eval.RamInc", source: "stage4.sumcheck", name: "stage4.ram_val_check.eval.RamInc", index: 1, oracle: "RamInc" },
 ];
 
-pub const STAGE4_POINT_SLICES: &[Stage4PointSlicePlan] = &[
-    Stage4PointSlicePlan { symbol: "stage4.registers_read_write.point.RdInc", source: "stage4.registers_read_write.instance", offset: 7, length: 16, input: "stage4.registers_read_write.instance" },
-    Stage4PointSlicePlan { symbol: "stage4.ram_val_check.point.RamAddress", source: "stage4.input.stage2.RamVal", offset: 0, length: 16, input: "stage4.input.stage2.RamVal" },
+pub const STAGE4_POINT_EXPRS: &[Stage4PointExprPlan] = &[
+    Stage4PointExprPlan { symbol: "stage4.registers_read_write.point.RdInc", kind: Stage4PointExprKind::Slice { offset: 7, length: 16 }, operands: &["stage4.registers_read_write.instance"] },
+    Stage4PointExprPlan { symbol: "stage4.ram_val_check.point.RamAddress", kind: Stage4PointExprKind::Slice { offset: 0, length: 16 }, operands: &["stage4.input.stage2.RamVal"] },
+    Stage4PointExprPlan { symbol: "stage4.ram_val_check.point.RamRa", kind: Stage4PointExprKind::Concat { layout: "address_then_cycle", arity: 32 }, operands: &["stage4.ram_val_check.point.RamAddress", "stage4.ram_val_check.instance"] },
 ];
 
-pub const STAGE4_POINT_CONCATS: &[Stage4PointConcatPlan] = &[
-    Stage4PointConcatPlan { symbol: "stage4.ram_val_check.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: "stage4.ram_val_check.point.RamAddress|stage4.ram_val_check.instance" },
-];
 pub const STAGE4_OPENING_CLAIMS: &[Stage4OpeningClaimPlan] = &[
-    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RegistersVal" },
-    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.Rs1Ra", oracle: "Rs1Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.Rs1Ra" },
-    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.Rs2Ra", oracle: "Rs2Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.Rs2Ra" },
-    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RdWa" },
-    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage4.registers_read_write.point.RdInc", eval_source: "stage4.registers_read_write.eval.RdInc" },
-    Stage4OpeningClaimPlan { symbol: "stage4.ram_val_check.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage4.ram_val_check.point.RamRa", eval_source: "stage4.ram_val_check.eval.RamRa" },
-    Stage4OpeningClaimPlan { symbol: "stage4.ram_val_check.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage4.ram_val_check.instance", eval_source: "stage4.ram_val_check.eval.RamInc" },
+    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RegistersVal" },
+    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.Rs1Ra", oracle: "Rs1Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.Rs1Ra" },
+    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.Rs2Ra", oracle: "Rs2Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.Rs2Ra" },
+    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RdWa" },
+    Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Committed, point_source: "stage4.registers_read_write.point.RdInc", eval_source: "stage4.registers_read_write.eval.RdInc" },
+    Stage4OpeningClaimPlan { symbol: "stage4.ram_val_check.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.ram_val_check.point.RamRa", eval_source: "stage4.ram_val_check.eval.RamRa" },
+    Stage4OpeningClaimPlan { symbol: "stage4.ram_val_check.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Committed, point_source: "stage4.ram_val_check.instance", eval_source: "stage4.ram_val_check.eval.RamInc" },
 ];
 
 pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[
-    Stage4OpeningClaimEqualityPlan { symbol: "stage4.registers.rs1_claim_consistency", mode: "point_and_eval", lhs: "stage4.input.stage3.registers.Rs1Value", rhs: "stage4.input.stage3.instruction.Rs1Value" },
-    Stage4OpeningClaimEqualityPlan { symbol: "stage4.registers.rs2_claim_consistency", mode: "point_and_eval", lhs: "stage4.input.stage3.registers.Rs2Value", rhs: "stage4.input.stage3.instruction.Rs2Value" },
+    Stage4OpeningClaimEqualityPlan { symbol: "stage4.registers.rs1_claim_consistency", mode: Stage4OpeningEqualityMode::PointAndEval, lhs: "stage4.input.stage3.registers.Rs1Value", rhs: "stage4.input.stage3.instruction.Rs1Value" },
+    Stage4OpeningClaimEqualityPlan { symbol: "stage4.registers.rs2_claim_consistency", mode: Stage4OpeningEqualityMode::PointAndEval, lhs: "stage4.input.stage3.registers.Rs2Value", rhs: "stage4.input.stage3.instruction.Rs2Value" },
 ];
 
 pub const STAGE4_OPENING_BATCHES: &[Stage4OpeningBatchPlan] = &[
-    Stage4OpeningBatchPlan { symbol: "stage4.openings", stage: "stage4", proof_slot: "stage4.openings", policy: "jolt_stage4_output_order", count: 7, ordered_claims: "stage4.registers_read_write.opening.RegistersVal|stage4.registers_read_write.opening.Rs1Ra|stage4.registers_read_write.opening.Rs2Ra|stage4.registers_read_write.opening.RdWa|stage4.registers_read_write.opening.RdInc|stage4.ram_val_check.opening.RamRa|stage4.ram_val_check.opening.RamInc", claim_operands: "stage4.registers_read_write.opening.RegistersVal|stage4.registers_read_write.opening.Rs1Ra|stage4.registers_read_write.opening.Rs2Ra|stage4.registers_read_write.opening.RdWa|stage4.registers_read_write.opening.RdInc|stage4.ram_val_check.opening.RamRa|stage4.ram_val_check.opening.RamInc" },
+    Stage4OpeningBatchPlan { symbol: "stage4.openings", stage: "stage4", proof_slot: "stage4.openings", policy: "jolt_stage4_output_order", count: 7, ordered_claims: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"], claim_operands: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"] },
 ];
+pub const STAGE4_RELATION_OUTPUTS: &[Stage4RelationOutputPlan] = &[
+    Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" },
+    Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" },
+];
+
 pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan {
     role: "verifier",
     params: STAGE4_PARAMS,
@@ -169,14 +186,16 @@ pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan {
     opening_inputs: STAGE4_OPENING_INPUTS,
     field_constants: STAGE4_FIELD_CONSTANTS,
     field_exprs: STAGE4_FIELD_EXPRS,
+    scalar_exprs: STAGE4_SCALAR_EXPRS,
     kernels: STAGE4_KERNELS,
     claims: STAGE4_SUMCHECK_CLAIMS,
     batches: STAGE4_SUMCHECK_BATCHES,
     drivers: STAGE4_SUMCHECK_DRIVERS,
     instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS,
     evals: STAGE4_SUMCHECK_EVALS,
-    point_slices: STAGE4_POINT_SLICES,
-    point_concats: STAGE4_POINT_CONCATS,
+    indexed_eval_families: &[],
+    relation_outputs: STAGE4_RELATION_OUTPUTS,
+    point_exprs: STAGE4_POINT_EXPRS,
     opening_claims: STAGE4_OPENING_CLAIMS,
     opening_equalities: STAGE4_OPENING_EQUALITIES,
     opening_batches: STAGE4_OPENING_BATCHES,
@@ -209,19 +228,19 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
     let mut artifacts = Stage4ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage4ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage4Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage4_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "transcript_absorb_bytes" => {
+            Stage4ProgramStepKind::TranscriptAbsorbBytes => {
                 let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or(
                     VerifyStage4Error::MissingValue {
                         symbol: step.symbol,
@@ -229,19 +248,13 @@ where
                 )?;
                 absorb_stage4_bytes(absorb, transcript);
             }
-            "sumcheck_driver" => {
+            Stage4ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage4Error::MissingProof {
                         driver: step.symbol,
                     })?;
                 verify_stage4_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?;
             }
-            _ => {
-                return Err(VerifyStage4Error::InvalidProof {
-                    driver: step.symbol,
-                    reason: "unsupported stage4 program step",
-                });
-            }
         }
     }
     artifacts
@@ -257,7 +270,7 @@ pub fn stage4_verifier_program() -> &'static Stage4VerifierProgramPlan {
 fn verify_stage4_squeeze<T>(
     program: &'static Stage4VerifierProgramPlan,
     squeeze: &'static Stage4TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage4ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage4Error>
@@ -273,7 +286,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage4Error::from)?;
     artifacts.challenge_vectors.push(Stage4ChallengeVector {
         symbol: squeeze.symbol,
@@ -297,7 +310,7 @@ fn verify_stage4_driver<T>(
     program: &'static Stage4VerifierProgramPlan,
     driver: &'static Stage4SumcheckDriverPlan,
     proof: &Stage4Proof<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage4ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage4Error>
@@ -310,12 +323,17 @@ where
         .ok_or(VerifyStage4Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage4Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage4.batched" => {
+        Stage4RelationKind::Stage4Batched => {
             verify_batched_stage4(program, driver, proof, store, transcript)?
         }
-        _ => return Err(VerifyStage4Error::UnsupportedRelation { relation }),
+        relation => return Err(VerifyStage4Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -325,25 +343,48 @@ fn verify_batched_stage4<T>(
     program: &'static Stage4VerifierProgramPlan,
     driver: &'static Stage4SumcheckDriverPlan,
     proof: &Stage4SumcheckOutput<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage4SumcheckOutput<Fr>, VerifyStage4Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage4Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs)
+            bolt_verifier_runtime::evaluate_relation_output_batch(
+                driver,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                &[],
+                store,
+                evals,
+                point,
+                batching_coeffs,
+                |_, _, _| Ok::<_, VerifyStage4Error>(bolt_verifier_runtime::RelationOutputInputs::empty()),
+            )
         },
         |store, verified| observe_stage4_sumcheck_output(program, store, verified),
         |driver, error| VerifyStage4Error::Sumcheck { driver, error },
@@ -352,7 +393,7 @@ where
 
 fn observe_stage4_sumcheck_output<F: Field>(
     program: &'static Stage4VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage4SumcheckOutput<F>,
 ) -> Result<(), VerifyStage4Error> {
     store.observe_sumcheck_output(
@@ -361,17 +402,17 @@ fn observe_stage4_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                "stage4_registers_rw" => {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
+                    if instance.relation != Stage4RelationKind::Stage4RegistersReadWrite {
+                        return Err(VerifyStage4Error::InvalidProof {
+                            driver: output.driver,
+                            reason: "unsupported relation-local point order",
+                        });
+                    }
                     point = normalize_stage4_registers_rw_point(program, output.driver, &point)?;
                 }
-                _ => {
-                    return Err(VerifyStage4Error::InvalidProof {
-                        driver: output.driver,
-                        reason: "unsupported point order",
-                    });
-                }
             }
             Ok(point)
         },
@@ -383,8 +424,7 @@ fn observe_stage4_sumcheck_output<F: Field>(
         |symbol| VerifyStage4Error::MissingValue { symbol },
     )?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage4Error::InvalidInputLength {
             input,
             expected,
@@ -392,7 +432,7 @@ fn observe_stage4_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage4Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -401,108 +441,6 @@ fn observe_stage4_sumcheck_output<F: Field>(
     )
 }
 
-fn expected_batched_output_claim(
-    program: &'static Stage4VerifierProgramPlan,
-    driver: &'static Stage4SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage4NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage4Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage4Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage4Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let relation = claim.relation.unwrap_or("<missing>");
-        let value = match relation {
-            "jolt.stage4.registers_read_write" => {
-                expected_registers_read_write(store, evals, local_point)?
-            }
-            "jolt.stage4.ram_val_check" => {
-                expected_ram_val_check(store, evals, local_point)?
-            }
-            _ => return Err(VerifyStage4Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_registers_read_write(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage4NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage4Error> {
-    let trace_point = super::common::store_point(store, "stage4.input.stage3.registers.RdWriteValue")?;
-    let r_cycle = normalize_stage4_registers_rw_cycle_point(
-        local_point,
-        trace_point.len(),
-        "stage4.registers_read_write.instance",
-    )?;
-    let eq_eval = EqPolynomial::<Fr>::mle(&r_cycle, trace_point);
-    let registers_val = eval_by_name(
-        evals,
-        "stage4.registers_read_write.eval.RegistersVal",
-    )?;
-    let rs1_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs1Ra")?;
-    let rs2_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs2Ra")?;
-    let rd_wa = eval_by_name(evals, "stage4.registers_read_write.eval.RdWa")?;
-    let rd_inc = eval_by_name(evals, "stage4.registers_read_write.eval.RdInc")?;
-    let gamma = super::common::store_scalar(store, "stage4.registers_read_write.gamma")?;
-    Ok(eq_eval
-        * (rd_wa * (registers_val + rd_inc)
-            + gamma * (rs1_ra * registers_val + gamma * rs2_ra * registers_val)))
-}
-
-fn expected_ram_val_check(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage4NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage4Error> {
-    let ram_val_point = super::common::store_point(store, "stage4.input.stage2.RamVal")?;
-    let r_cycle_prime = reverse_slice(local_point);
-    let r_cycle = suffix_point(
-        ram_val_point,
-        r_cycle_prime.len(),
-        "stage4.input.stage2.RamVal",
-    )?;
-    let lt_eval = lt_polynomial_eval(&r_cycle_prime, r_cycle);
-    let gamma = super::common::store_scalar(store, "stage4.ram_val_check.gamma")?;
-    let ram_ra = eval_by_name(evals, "stage4.ram_val_check.eval.RamRa")?;
-    let ram_inc = eval_by_name(evals, "stage4.ram_val_check.eval.RamInc")?;
-    Ok(ram_inc * ram_ra * (lt_eval + gamma))
-}
-
-fn suffix_point<'a>(
-    point: &'a [Fr],
-    length: usize,
-    input: &'static str,
-) -> Result<&'a [Fr], VerifyStage4Error> {
-    point
-        .get(point.len().saturating_sub(length)..)
-        .filter(|suffix| suffix.len() == length)
-        .ok_or(VerifyStage4Error::InvalidInputLength {
-            input,
-            expected: length,
-            actual: point.len(),
-        })
-}
-
 fn normalize_stage4_registers_rw_point<F: Field>(
     program: &'static Stage4VerifierProgramPlan,
     driver: &'static str,
@@ -534,19 +472,3 @@ fn normalize_stage4_registers_rw_point<F: Field>(
         .chain(cycle.iter().rev().copied())
         .collect())
 }
-
-fn normalize_stage4_registers_rw_cycle_point<F: Field>(
-    point: &[F],
-    cycle_rounds: usize,
-    input: &'static str,
-) -> Result<Vec<F>, VerifyStage4Error> {
-    let cycle = point
-        .get(..cycle_rounds)
-        .filter(|cycle| cycle.len() == cycle_rounds)
-        .ok_or(VerifyStage4Error::InvalidInputLength {
-            input,
-            expected: cycle_rounds,
-            actual: point.len(),
-        })?;
-    Ok(cycle.iter().rev().copied().collect())
-}
diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs
index 034d2d9974..6d31cb01da 100644
--- a/crates/jolt-verifier/src/stages/stage5.rs
+++ b/crates/jolt-verifier/src/stages/stage5.rs
@@ -1,37 +1,59 @@
 #![allow(dead_code)]
 
-use super::common::{batch_claims, eval_by_name, find_batch, find_plan, identity_polynomial_eval, indexed_evals_by_prefix_any, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval, reverse_slice, suffix_point};
-use jolt_field::{Field, Fr, RingCore};
-use jolt_lookup_tables::LookupTableKind;
-use jolt_poly::EqPolynomial;
+use bolt_verifier_runtime::find_plan;
+use super::jolt_relations::{evaluate_stage5_instruction_read_raf_local_scalars, normalize_instruction_read_raf_point, JoltLocalScalarMleKind, JoltLocalScalarPlan, Stage5InstructionReadRafPlan};
+use jolt_field::{Field, Fr};
 use jolt_sumcheck::SumcheckError;
 use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};
 
-pub type Stage5NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage5SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage5ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage5ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage5Proof<F> = super::common::StageProof<F>;
-pub type Stage5OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-
-pub use super::common::{
-    FieldConstantPlan as Stage5FieldConstantPlan, FieldExprPlan as Stage5FieldExprPlan,
+pub type Stage5NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage5SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage5ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage5ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage5Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage5OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan<Stage5RelationKind>;
+pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage5RelationKind>;
+pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage5RelationKind>;
+pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage5RelationKind>;
+pub type Stage5RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage5RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage5ClaimKind, FieldConstantPlan as Stage5FieldConstantPlan,
+    FieldExprKind as Stage5FieldExprKind,
+    FieldExprPlan as Stage5FieldExprPlan,
+    ScalarExprKind as Stage5ScalarExprKind,
+    ScalarExprPlan as Stage5ScalarExprPlan,
     KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan,
-    PointConcatPlan as Stage5PointConcatPlan, PointSlicePlan as Stage5PointSlicePlan,
+    OpeningEqualityMode as Stage5OpeningEqualityMode, PointExprKind as Stage5PointExprKind,
+    PointExprPlan as Stage5PointExprPlan,
+    ProgramStepKind as Stage5ProgramStepKind,
     ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params,
-    StageProgramPlanNoPointZeros as Stage5CpuProgramPlan,
     SumcheckBatchPlan as Stage5SumcheckBatchPlan,
-    SumcheckClaimPlan as Stage5SumcheckClaimPlan, SumcheckDriverPlan as Stage5SumcheckDriverPlan,
     SumcheckEvalPlan as Stage5SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage5SumcheckInstanceResultPlan,
     TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan,
+    TranscriptSqueezeKind as Stage5TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage5TranscriptSqueezePlan,
 };
 
 pub type DefaultStage5Transcript = Blake2bTranscript<Fr>;
-pub type Stage5VerifierProgramPlan = Stage5CpuProgramPlan;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage5VerifierProgramPlan {
+    pub base: Stage5CpuProgramPlan,
+    pub instruction_read_raf_plan: Stage5InstructionReadRafPlan,
+}
+
+impl core::ops::Deref for Stage5VerifierProgramPlan {
+    type Target = Stage5CpuProgramPlan;
+
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
+}
 
 #[derive(Debug)]
 pub enum VerifyStage5Error {
@@ -42,27 +64,22 @@ pub enum VerifyStage5Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage5RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error);
 
-pub const STAGE5_PARAMS: Stage5Params = Stage5Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE5_PARAMS: Stage5Params = Stage5Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE5_PROGRAM_STEPS: &[Stage5ProgramStepPlan] = &[
-    Stage5ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage5.instruction_read_raf.gamma" },
-    Stage5ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage5.ram_ra_claim_reduction.gamma" },
-    Stage5ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage5.sumcheck" },
+    Stage5ProgramStepPlan { kind: Stage5ProgramStepKind::TranscriptSqueeze, symbol: "stage5.instruction_read_raf.gamma" },
+    Stage5ProgramStepPlan { kind: Stage5ProgramStepKind::TranscriptSqueeze, symbol: "stage5.ram_ra_claim_reduction.gamma" },
+    Stage5ProgramStepPlan { kind: Stage5ProgramStepKind::SumcheckDriver, symbol: "stage5.sumcheck" },
 ];
 
 pub const STAGE5_TRANSCRIPT_SQUEEZES: &[Stage5TranscriptSqueezePlan] = &[
-    Stage5TranscriptSqueezePlan { symbol: "stage5.instruction_read_raf.gamma", label: "instruction_read_raf_gamma", kind: "challenge_scalar", count: 1 },
-    Stage5TranscriptSqueezePlan { symbol: "stage5.ram_ra_claim_reduction.gamma", label: "ram_ra_claim_reduction_gamma", kind: "challenge_scalar", count: 1 },
+    Stage5TranscriptSqueezePlan { symbol: "stage5.instruction_read_raf.gamma", label: "instruction_read_raf_gamma", kind: Stage5TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage5TranscriptSqueezePlan { symbol: "stage5.ram_ra_claim_reduction.gamma", label: "ram_ra_claim_reduction_gamma", kind: Stage5TranscriptSqueezeKind::ChallengeScalar, count: 1 },
 ];
 
 pub const STAGE5_TRANSCRIPT_ABSORB_BYTES: &[Stage5TranscriptAbsorbBytesPlan] = &[
@@ -70,14 +87,14 @@ pub const STAGE5_TRANSCRIPT_ABSORB_BYTES: &[Stage5TranscriptAbsorbBytesPlan] = &
 ];
 
 pub const STAGE5_OPENING_INPUTS: &[Stage5OpeningInputPlan] = &[
-    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.LookupOutput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.product_virtual.LookupOutput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.LeftLookupOperand", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.RightLookupOperand", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.ram_raf.RamRa", source_stage: "stage2", source_claim: "stage2.ram_raf.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.ram_read_write.RamRa", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage5OpeningInputPlan { symbol: "stage5.input.stage4.ram_val_check.RamRa", source_stage: "stage4", source_claim: "stage4.ram_val_check.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage5OpeningInputPlan { symbol: "stage5.input.stage4.registers.RegistersVal", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" },
+    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.LookupOutput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual },
+    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.product_virtual.LookupOutput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual },
+    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.LeftLookupOperand", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual },
+    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.RightLookupOperand", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual },
+    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.ram_raf.RamRa", source_stage: "stage2", source_claim: "stage2.ram_raf.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual },
+    Stage5OpeningInputPlan { symbol: "stage5.input.stage2.ram_read_write.RamRa", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual },
+    Stage5OpeningInputPlan { symbol: "stage5.input.stage4.ram_val_check.RamRa", source_stage: "stage4", source_claim: "stage4.ram_val_check.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual },
+    Stage5OpeningInputPlan { symbol: "stage5.input.stage4.registers.RegistersVal", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage5ClaimKind::Virtual },
 ];
 
 pub const STAGE5_FIELD_CONSTANTS: &[Stage5FieldConstantPlan] = &[
@@ -85,46 +102,108 @@ pub const STAGE5_FIELD_CONSTANTS: &[Stage5FieldConstantPlan] = &[
 ];
 
 pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[
-    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.gamma2", kind: "op", formula: "field.pow:2", operands: "stage5.instruction_read_raf.gamma" },
-    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.LeftLookupOperand", kind: "op", formula: "field.mul", operands: "stage5.instruction_read_raf.gamma|stage5.input.stage2.instruction.LeftLookupOperand" },
-    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.RightLookupOperand", kind: "op", formula: "field.mul", operands: "stage5.instruction_read_raf.gamma2|stage5.input.stage2.instruction.RightLookupOperand" },
-    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand", kind: "op", formula: "field.add", operands: "stage5.input.stage2.instruction.LookupOutput|stage5.instruction_read_raf.term.LeftLookupOperand" },
-    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.claim_expr", kind: "op", formula: "field.add", operands: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand|stage5.instruction_read_raf.term.RightLookupOperand" },
-    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.gamma2", kind: "op", formula: "field.pow:2", operands: "stage5.ram_ra_claim_reduction.gamma" },
-    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaReadWrite", kind: "op", formula: "field.mul", operands: "stage5.ram_ra_claim_reduction.gamma|stage5.input.stage2.ram_read_write.RamRa" },
-    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaValCheck", kind: "op", formula: "field.mul", operands: "stage5.ram_ra_claim_reduction.gamma2|stage5.input.stage4.ram_val_check.RamRa" },
-    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.partial.RafReadWrite", kind: "op", formula: "field.add", operands: "stage5.input.stage2.ram_raf.RamRa|stage5.ram_ra_claim_reduction.term.RamRaReadWrite" },
-    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.claim_expr", kind: "op", formula: "field.add", operands: "stage5.ram_ra_claim_reduction.partial.RafReadWrite|stage5.ram_ra_claim_reduction.term.RamRaValCheck" },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.gamma2", kind: Stage5FieldExprKind::Pow(2), operands: &["stage5.instruction_read_raf.gamma"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.LeftLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.input.stage2.instruction.LeftLookupOperand"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.RightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma2", "stage5.input.stage2.instruction.RightLookupOperand"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand", kind: Stage5FieldExprKind::Add, operands: &["stage5.input.stage2.instruction.LookupOutput", "stage5.instruction_read_raf.term.LeftLookupOperand"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.claim_expr", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.partial.LookupOutputLeftOperand", "stage5.instruction_read_raf.term.RightLookupOperand"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.gamma2", kind: Stage5FieldExprKind::Pow(2), operands: &["stage5.ram_ra_claim_reduction.gamma"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaReadWrite", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.gamma", "stage5.input.stage2.ram_read_write.RamRa"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaValCheck", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.gamma2", "stage5.input.stage4.ram_val_check.RamRa"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.partial.RafReadWrite", kind: Stage5FieldExprKind::Add, operands: &["stage5.input.stage2.ram_raf.RamRa", "stage5.ram_ra_claim_reduction.term.RamRaReadWrite"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.claim_expr", kind: Stage5FieldExprKind::Add, operands: &["stage5.ram_ra_claim_reduction.partial.RafReadWrite", "stage5.ram_ra_claim_reduction.term.RamRaValCheck"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.term.ReadWrite", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.gamma", "stage5.ram_ra_claim_reduction.output.eq.ReadWrite"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.term.ValCheck", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.gamma2", "stage5.ram_ra_claim_reduction.output.eq.ValCheck"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.partial.RafReadWrite", kind: Stage5FieldExprKind::Add, operands: &["stage5.ram_ra_claim_reduction.output.eq.Raf", "stage5.ram_ra_claim_reduction.output.term.ReadWrite"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq_combined", kind: Stage5FieldExprKind::Add, operands: &["stage5.ram_ra_claim_reduction.output.partial.RafReadWrite", "stage5.ram_ra_claim_reduction.output.term.ValCheck"] },
+    Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.output.eq_combined", "stage5.ram_ra_claim_reduction.eval.RamRa"] },
+    Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.product.RdIncRdWa", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.eval.RdInc", "stage5.registers_val_evaluation.eval.RdWa"] },
+    Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.output.product.RdIncRdWa", "stage5.registers_val_evaluation.output.lt.RegistersValCycle"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_0", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_1", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_2", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_3", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_4", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_5", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_6", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_7", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_8", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_9", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_10", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_11", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_12", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_13", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_14", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_15", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_16", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_17", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_18", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_19", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_20", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_21", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_22", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_23", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_24", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_25", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_26", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_27", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_28", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_29", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_30", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_31", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_32", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_33", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_34", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_35", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_36", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_37", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_38", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_39", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_40", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", kind: Stage5FieldExprKind::Sum, operands: &["stage5.instruction_read_raf.output.term.LookupTableValue_0", "stage5.instruction_read_raf.output.term.LookupTableValue_1", "stage5.instruction_read_raf.output.term.LookupTableValue_2", "stage5.instruction_read_raf.output.term.LookupTableValue_3", "stage5.instruction_read_raf.output.term.LookupTableValue_4", "stage5.instruction_read_raf.output.term.LookupTableValue_5", "stage5.instruction_read_raf.output.term.LookupTableValue_6", "stage5.instruction_read_raf.output.term.LookupTableValue_7", "stage5.instruction_read_raf.output.term.LookupTableValue_8", "stage5.instruction_read_raf.output.term.LookupTableValue_9", "stage5.instruction_read_raf.output.term.LookupTableValue_10", "stage5.instruction_read_raf.output.term.LookupTableValue_11", "stage5.instruction_read_raf.output.term.LookupTableValue_12", "stage5.instruction_read_raf.output.term.LookupTableValue_13", "stage5.instruction_read_raf.output.term.LookupTableValue_14", "stage5.instruction_read_raf.output.term.LookupTableValue_15", "stage5.instruction_read_raf.output.term.LookupTableValue_16", "stage5.instruction_read_raf.output.term.LookupTableValue_17", "stage5.instruction_read_raf.output.term.LookupTableValue_18", "stage5.instruction_read_raf.output.term.LookupTableValue_19", "stage5.instruction_read_raf.output.term.LookupTableValue_20", "stage5.instruction_read_raf.output.term.LookupTableValue_21", "stage5.instruction_read_raf.output.term.LookupTableValue_22", "stage5.instruction_read_raf.output.term.LookupTableValue_23", "stage5.instruction_read_raf.output.term.LookupTableValue_24", "stage5.instruction_read_raf.output.term.LookupTableValue_25", "stage5.instruction_read_raf.output.term.LookupTableValue_26", "stage5.instruction_read_raf.output.term.LookupTableValue_27", "stage5.instruction_read_raf.output.term.LookupTableValue_28", "stage5.instruction_read_raf.output.term.LookupTableValue_29", "stage5.instruction_read_raf.output.term.LookupTableValue_30", "stage5.instruction_read_raf.output.term.LookupTableValue_31", "stage5.instruction_read_raf.output.term.LookupTableValue_32", "stage5.instruction_read_raf.output.term.LookupTableValue_33", "stage5.instruction_read_raf.output.term.LookupTableValue_34", "stage5.instruction_read_raf.output.term.LookupTableValue_35", "stage5.instruction_read_raf.output.term.LookupTableValue_36", "stage5.instruction_read_raf.output.term.LookupTableValue_37", "stage5.instruction_read_raf.output.term.LookupTableValue_38", "stage5.instruction_read_raf.output.term.LookupTableValue_39", "stage5.instruction_read_raf.output.term.LookupTableValue_40"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaRightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.local_scalar.RightLookupOperand"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.local_scalar.LeftLookupOperand", "stage5.instruction_read_raf.output.term.GammaRightLookupOperand"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.RafFlagLeftPlusGammaRight", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.eval.InstructionRafFlag", "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.NonRafLookupOperands", kind: Stage5FieldExprKind::Sub, operands: &["stage5.instruction_read_raf.output.partial.LeftPlusGammaRight", "stage5.instruction_read_raf.output.term.RafFlagLeftPlusGammaRight"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaIdentity", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.local_scalar.Identity"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.RafFlagGammaIdentity", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.eval.InstructionRafFlag", "stage5.instruction_read_raf.output.term.GammaIdentity"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.RafClaim", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.output.partial.NonRafLookupOperands", "stage5.instruction_read_raf.output.term.RafFlagGammaIdentity"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaRafClaim", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.output.partial.RafClaim"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.LookupOrRaf", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.output.product.LookupTableValues", "stage5.instruction_read_raf.output.term.GammaRafClaim"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.EqRa", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.output.eq.LookupOutputCycle", "stage5.instruction_read_raf.output.product.InstructionRa"] },
+    Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.output.partial.EqRa", "stage5.instruction_read_raf.output.partial.LookupOrRaf"] },
+];
+pub const STAGE5_SCALAR_EXPRS: &[Stage5ScalarExprPlan] = &[
+    Stage5ScalarExprPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", kind: Stage5ScalarExprKind::FieldVectorProduct, operands: &["stage5.instruction_read_raf.eval.InstructionRa"] },
+    Stage5ScalarExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage2.ram_raf.RamRa"] },
+    Stage5ScalarExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage2.ram_read_write.RamRa"] },
+    Stage5ScalarExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage4.ram_val_check.RamRa"] },
+    Stage5ScalarExprPlan { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Lt, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.registers_val_evaluation.instance", "stage5.input.stage4.registers.RegistersVal"] },
+    Stage5ScalarExprPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.instruction_read_raf.instance", "stage5.input.stage2.instruction.LookupOutput"] },
 ];
 pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[
 
 ];
 
 pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[
-    Stage5SumcheckClaimPlan { symbol: "stage5.instruction_read_raf.input", stage: "stage5", domain: "jolt.stage5_instruction_read_raf_domain", num_rounds: 144, degree: 10, claim: "stage5.instruction_read_raf.weighted_lookup_values", kernel: None, relation: Some("jolt.stage5.instruction_read_raf"), claim_value: "stage5.instruction_read_raf.claim_expr", input_openings: "stage5.input.stage2.instruction.LookupOutput|stage5.input.stage2.instruction.LeftLookupOperand|stage5.input.stage2.instruction.RightLookupOperand" },
-    Stage5SumcheckClaimPlan { symbol: "stage5.ram_ra_claim_reduction.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage5.ram_ra_claim_reduction.weighted_ram_ra", kernel: None, relation: Some("jolt.stage5.ram_ra_claim_reduction"), claim_value: "stage5.ram_ra_claim_reduction.claim_expr", input_openings: "stage5.input.stage2.ram_raf.RamRa|stage5.input.stage2.ram_read_write.RamRa|stage5.input.stage4.ram_val_check.RamRa" },
-    Stage5SumcheckClaimPlan { symbol: "stage5.registers_val_evaluation.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage5.registers_val_evaluation.registers_val", kernel: None, relation: Some("jolt.stage5.registers_val_evaluation"), claim_value: "stage5.input.stage4.registers.RegistersVal", input_openings: "stage5.input.stage4.registers.RegistersVal" },
-];
-pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    128,
-    16,
+    Stage5SumcheckClaimPlan { symbol: "stage5.instruction_read_raf.input", stage: "stage5", domain: "jolt.stage5_instruction_read_raf_domain", num_rounds: 144, degree: 10, claim: "stage5.instruction_read_raf.weighted_lookup_values", kernel: None, relation: Some(Stage5RelationKind::Stage5InstructionReadRaf), claim_value: "stage5.instruction_read_raf.claim_expr" },
+    Stage5SumcheckClaimPlan { symbol: "stage5.ram_ra_claim_reduction.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage5.ram_ra_claim_reduction.weighted_ram_ra", kernel: None, relation: Some(Stage5RelationKind::Stage5RamRaClaimReduction), claim_value: "stage5.ram_ra_claim_reduction.claim_expr" },
+    Stage5SumcheckClaimPlan { symbol: "stage5.registers_val_evaluation.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage5.registers_val_evaluation.registers_val", kernel: None, relation: Some(Stage5RelationKind::Stage5RegistersValEvaluation), claim_value: "stage5.input.stage4.registers.RegistersVal" },
 ];
+pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[128, 16];
 
 pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[
-    Stage5SumcheckBatchPlan { symbol: "stage5.batch", stage: "stage5", proof_slot: "stage5.sumcheck", policy: "jolt_core_stage5_aligned", count: 3, ordered_claims: "stage5.instruction_read_raf.input|stage5.ram_ra_claim_reduction.input|stage5.registers_val_evaluation.input", claim_operands: "stage5.instruction_read_raf.input|stage5.ram_ra_claim_reduction.input|stage5.registers_val_evaluation.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
-];
-pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    128,
-    16,
+    Stage5SumcheckBatchPlan { symbol: "stage5.batch", stage: "stage5", proof_slot: "stage5.sumcheck", policy: "jolt_core_stage5_aligned", count: 3, claim_operands: &["stage5.instruction_read_raf.input", "stage5.ram_ra_claim_reduction.input", "stage5.registers_val_evaluation.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
+pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[128, 16];
 
 pub const STAGE5_SUMCHECK_DRIVERS: &[Stage5SumcheckDriverPlan] = &[
-    Stage5SumcheckDriverPlan { symbol: "stage5.sumcheck", stage: "stage5", proof_slot: "stage5.sumcheck", kernel: None, relation: Some("jolt.stage5.batched"), batch: "stage5.batch", policy: "jolt_core_stage5_aligned", round_schedule: STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 144, degree: 10 },
+    Stage5SumcheckDriverPlan { symbol: "stage5.sumcheck", stage: "stage5", proof_slot: "stage5.sumcheck", kernel: None, relation: Some(Stage5RelationKind::Stage5Batched), batch: "stage5.batch", policy: "jolt_core_stage5_aligned", round_schedule: STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 144, degree: 10 },
 ];
 pub const STAGE5_SUMCHECK_INSTANCE_RESULTS: &[Stage5SumcheckInstanceResultPlan] = &[
-    Stage5SumcheckInstanceResultPlan { symbol: "stage5.instruction_read_raf.instance", source: "stage5.sumcheck", claim: "stage5.instruction_read_raf.input", relation: "jolt.stage5.instruction_read_raf", index: 0, point_arity: 144, num_rounds: 144, round_offset: 0, point_order: "instruction_read_raf", degree: 10 },
-    Stage5SumcheckInstanceResultPlan { symbol: "stage5.ram_ra_claim_reduction.instance", source: "stage5.sumcheck", claim: "stage5.ram_ra_claim_reduction.input", relation: "jolt.stage5.ram_ra_claim_reduction", index: 1, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: "reverse", degree: 2 },
-    Stage5SumcheckInstanceResultPlan { symbol: "stage5.registers_val_evaluation.instance", source: "stage5.sumcheck", claim: "stage5.registers_val_evaluation.input", relation: "jolt.stage5.registers_val_evaluation", index: 2, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: "reverse", degree: 3 },
+    Stage5SumcheckInstanceResultPlan { symbol: "stage5.instruction_read_raf.instance", source: "stage5.sumcheck", claim: "stage5.instruction_read_raf.input", relation: Stage5RelationKind::Stage5InstructionReadRaf, index: 0, point_arity: 144, num_rounds: 144, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::RelationLocal, degree: 10 },
+    Stage5SumcheckInstanceResultPlan { symbol: "stage5.ram_ra_claim_reduction.instance", source: "stage5.sumcheck", claim: "stage5.ram_ra_claim_reduction.input", relation: Stage5RelationKind::Stage5RamRaClaimReduction, index: 1, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 },
+    Stage5SumcheckInstanceResultPlan { symbol: "stage5.registers_val_evaluation.instance", source: "stage5.sumcheck", claim: "stage5.registers_val_evaluation.input", relation: Stage5RelationKind::Stage5RegistersValEvaluation, index: 2, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 },
 ];
 
 pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[
@@ -183,115 +262,192 @@ pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[
     Stage5SumcheckEvalPlan { symbol: "stage5.registers_val_evaluation.eval.RdWa", source: "stage5.sumcheck", name: "stage5.registers_val_evaluation.eval.RdWa", index: 1, oracle: "RdWa" },
 ];
 
-pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[
-    Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.Cycle", source: "stage5.instruction_read_raf.instance", offset: 128, length: 16, input: "stage5.instruction_read_raf.instance" },
-    Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0.address", source: "stage5.instruction_read_raf.instance", offset: 0, length: 16, input: "stage5.instruction_read_raf.instance" },
-    Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1.address", source: "stage5.instruction_read_raf.instance", offset: 16, length: 16, input: "stage5.instruction_read_raf.instance" },
-    Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2.address", source: "stage5.instruction_read_raf.instance", offset: 32, length: 16, input: "stage5.instruction_read_raf.instance" },
-    Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3.address", source: "stage5.instruction_read_raf.instance", offset: 48, length: 16, input: "stage5.instruction_read_raf.instance" },
-    Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4.address", source: "stage5.instruction_read_raf.instance", offset: 64, length: 16, input: "stage5.instruction_read_raf.instance" },
-    Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5.address", source: "stage5.instruction_read_raf.instance", offset: 80, length: 16, input: "stage5.instruction_read_raf.instance" },
-    Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6.address", source: "stage5.instruction_read_raf.instance", offset: 96, length: 16, input: "stage5.instruction_read_raf.instance" },
-    Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7.address", source: "stage5.instruction_read_raf.instance", offset: 112, length: 16, input: "stage5.instruction_read_raf.instance" },
-    Stage5PointSlicePlan { symbol: "stage5.ram_ra_claim_reduction.point.RamAddress", source: "stage5.input.stage2.ram_raf.RamRa", offset: 0, length: 16, input: "stage5.input.stage2.ram_raf.RamRa" },
-    Stage5PointSlicePlan { symbol: "stage5.registers_val_evaluation.point.RegisterAddress", source: "stage5.input.stage4.registers.RegistersVal", offset: 0, length: 7, input: "stage5.input.stage4.registers.RegistersVal" },
+pub const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS: &[JoltLocalScalarPlan] = &[
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_0", kind: JoltLocalScalarMleKind::LookupTable { index: 0 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_1", kind: JoltLocalScalarMleKind::LookupTable { index: 1 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_2", kind: JoltLocalScalarMleKind::LookupTable { index: 2 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_3", kind: JoltLocalScalarMleKind::LookupTable { index: 3 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_4", kind: JoltLocalScalarMleKind::LookupTable { index: 4 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_5", kind: JoltLocalScalarMleKind::LookupTable { index: 5 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_6", kind: JoltLocalScalarMleKind::LookupTable { index: 6 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_7", kind: JoltLocalScalarMleKind::LookupTable { index: 7 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_8", kind: JoltLocalScalarMleKind::LookupTable { index: 8 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_9", kind: JoltLocalScalarMleKind::LookupTable { index: 9 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_10", kind: JoltLocalScalarMleKind::LookupTable { index: 10 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_11", kind: JoltLocalScalarMleKind::LookupTable { index: 11 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_12", kind: JoltLocalScalarMleKind::LookupTable { index: 12 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_13", kind: JoltLocalScalarMleKind::LookupTable { index: 13 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_14", kind: JoltLocalScalarMleKind::LookupTable { index: 14 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_15", kind: JoltLocalScalarMleKind::LookupTable { index: 15 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_16", kind: JoltLocalScalarMleKind::LookupTable { index: 16 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_17", kind: JoltLocalScalarMleKind::LookupTable { index: 17 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_18", kind: JoltLocalScalarMleKind::LookupTable { index: 18 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_19", kind: JoltLocalScalarMleKind::LookupTable { index: 19 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_20", kind: JoltLocalScalarMleKind::LookupTable { index: 20 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_21", kind: JoltLocalScalarMleKind::LookupTable { index: 21 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_22", kind: JoltLocalScalarMleKind::LookupTable { index: 22 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_23", kind: JoltLocalScalarMleKind::LookupTable { index: 23 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_24", kind: JoltLocalScalarMleKind::LookupTable { index: 24 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_25", kind: JoltLocalScalarMleKind::LookupTable { index: 25 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_26", kind: JoltLocalScalarMleKind::LookupTable { index: 26 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_27", kind: JoltLocalScalarMleKind::LookupTable { index: 27 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_28", kind: JoltLocalScalarMleKind::LookupTable { index: 28 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_29", kind: JoltLocalScalarMleKind::LookupTable { index: 29 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_30", kind: JoltLocalScalarMleKind::LookupTable { index: 30 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_31", kind: JoltLocalScalarMleKind::LookupTable { index: 31 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_32", kind: JoltLocalScalarMleKind::LookupTable { index: 32 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_33", kind: JoltLocalScalarMleKind::LookupTable { index: 33 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_34", kind: JoltLocalScalarMleKind::LookupTable { index: 34 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_35", kind: JoltLocalScalarMleKind::LookupTable { index: 35 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_36", kind: JoltLocalScalarMleKind::LookupTable { index: 36 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_37", kind: JoltLocalScalarMleKind::LookupTable { index: 37 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_38", kind: JoltLocalScalarMleKind::LookupTable { index: 38 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_39", kind: JoltLocalScalarMleKind::LookupTable { index: 39 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_40", kind: JoltLocalScalarMleKind::LookupTable { index: 40 } },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LeftLookupOperand", kind: JoltLocalScalarMleKind::LeftOperand },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.RightLookupOperand", kind: JoltLocalScalarMleKind::RightOperand },
+    JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.Identity", kind: JoltLocalScalarMleKind::Identity },
 ];
 
-pub const STAGE5_POINT_CONCATS: &[Stage5PointConcatPlan] = &[
-    Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_0.address|stage5.instruction_read_raf.point.Cycle" },
-    Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_1.address|stage5.instruction_read_raf.point.Cycle" },
-    Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_2.address|stage5.instruction_read_raf.point.Cycle" },
-    Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_3.address|stage5.instruction_read_raf.point.Cycle" },
-    Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_4.address|stage5.instruction_read_raf.point.Cycle" },
-    Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_5.address|stage5.instruction_read_raf.point.Cycle" },
-    Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_6.address|stage5.instruction_read_raf.point.Cycle" },
-    Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_7.address|stage5.instruction_read_raf.point.Cycle" },
-    Stage5PointConcatPlan { symbol: "stage5.ram_ra_claim_reduction.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: "stage5.ram_ra_claim_reduction.point.RamAddress|stage5.ram_ra_claim_reduction.instance" },
-    Stage5PointConcatPlan { symbol: "stage5.registers_val_evaluation.point.RdWa", layout: "register_address_then_cycle", arity: 23, inputs: "stage5.registers_val_evaluation.point.RegisterAddress|stage5.registers_val_evaluation.instance" },
+pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan {
+    point: "stage5.instruction_read_raf.instance",
+    lookup_output_point: "stage5.input.stage2.instruction.LookupOutput",
+    table_flag_evals: &STAGE5_INDEXED_EVAL_FAMILIES[0],
+    instruction_ra_evals: &STAGE5_INDEXED_EVAL_FAMILIES[1],
+    raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag",
+    gamma: "stage5.instruction_read_raf.gamma",
+    local_scalars: STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS,
+    log_k: 128,
+};
+
+pub const STAGE5_POINT_EXPRS: &[Stage5PointExprPlan] = &[
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.Cycle", kind: Stage5PointExprKind::Slice { offset: 128, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0.address", kind: Stage5PointExprKind::Slice { offset: 0, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1.address", kind: Stage5PointExprKind::Slice { offset: 16, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2.address", kind: Stage5PointExprKind::Slice { offset: 32, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3.address", kind: Stage5PointExprKind::Slice { offset: 48, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4.address", kind: Stage5PointExprKind::Slice { offset: 64, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5.address", kind: Stage5PointExprKind::Slice { offset: 80, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6.address", kind: Stage5PointExprKind::Slice { offset: 96, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7.address", kind: Stage5PointExprKind::Slice { offset: 112, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.ram_ra_claim_reduction.point.RamAddress", kind: Stage5PointExprKind::Slice { offset: 0, length: 16 }, operands: &["stage5.input.stage2.ram_raf.RamRa"] },
+    Stage5PointExprPlan { symbol: "stage5.registers_val_evaluation.point.RegisterAddress", kind: Stage5PointExprKind::Slice { offset: 0, length: 7 }, operands: &["stage5.input.stage4.registers.RegistersVal"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_0.address", "stage5.instruction_read_raf.point.Cycle"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_1.address", "stage5.instruction_read_raf.point.Cycle"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_2.address", "stage5.instruction_read_raf.point.Cycle"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_3.address", "stage5.instruction_read_raf.point.Cycle"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_4.address", "stage5.instruction_read_raf.point.Cycle"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_5.address", "stage5.instruction_read_raf.point.Cycle"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_6.address", "stage5.instruction_read_raf.point.Cycle"] },
+    Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_7.address", "stage5.instruction_read_raf.point.Cycle"] },
+    Stage5PointExprPlan { symbol: "stage5.ram_ra_claim_reduction.point.RamRa", kind: Stage5PointExprKind::Concat { layout: "address_then_cycle", arity: 32 }, operands: &["stage5.ram_ra_claim_reduction.point.RamAddress", "stage5.ram_ra_claim_reduction.instance"] },
+    Stage5PointExprPlan { symbol: "stage5.registers_val_evaluation.point.RdWa", kind: Stage5PointExprKind::Concat { layout: "register_address_then_cycle", arity: 23 }, operands: &["stage5.registers_val_evaluation.point.RegisterAddress", "stage5.registers_val_evaluation.instance"] },
 ];
+
 pub const STAGE5_OPENING_CLAIMS: &[Stage5OpeningClaimPlan] = &[
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_0" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_1", oracle: "LookupTableFlag_1", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_1" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_2", oracle: "LookupTableFlag_2", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_2" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_3", oracle: "LookupTableFlag_3", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_3" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_4", oracle: "LookupTableFlag_4", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_4" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_5", oracle: "LookupTableFlag_5", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_5" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_6", oracle: "LookupTableFlag_6", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_6" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_7", oracle: "LookupTableFlag_7", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_7" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_8", oracle: "LookupTableFlag_8", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_8" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_9", oracle: "LookupTableFlag_9", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_9" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_10", oracle: "LookupTableFlag_10", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_10" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_11", oracle: "LookupTableFlag_11", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_11" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_12", oracle: "LookupTableFlag_12", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_12" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_13", oracle: "LookupTableFlag_13", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_13" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_14", oracle: "LookupTableFlag_14", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_14" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_15", oracle: "LookupTableFlag_15", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_15" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_16", oracle: "LookupTableFlag_16", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_16" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_17", oracle: "LookupTableFlag_17", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_17" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_18", oracle: "LookupTableFlag_18", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_18" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_19", oracle: "LookupTableFlag_19", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_19" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_20", oracle: "LookupTableFlag_20", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_20" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_21", oracle: "LookupTableFlag_21", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_21" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_22", oracle: "LookupTableFlag_22", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_22" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_23", oracle: "LookupTableFlag_23", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_23" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_24", oracle: "LookupTableFlag_24", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_24" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_25", oracle: "LookupTableFlag_25", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_25" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_26", oracle: "LookupTableFlag_26", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_26" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_27", oracle: "LookupTableFlag_27", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_27" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_28", oracle: "LookupTableFlag_28", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_28" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_29", oracle: "LookupTableFlag_29", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_29" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_30", oracle: "LookupTableFlag_30", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_30" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_31", oracle: "LookupTableFlag_31", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_31" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_32", oracle: "LookupTableFlag_32", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_32" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_33", oracle: "LookupTableFlag_33", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_33" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_34", oracle: "LookupTableFlag_34", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_34" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_35", oracle: "LookupTableFlag_35", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_35" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_36", oracle: "LookupTableFlag_36", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_36" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_37", oracle: "LookupTableFlag_37", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_37" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_38", oracle: "LookupTableFlag_38", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_38" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_39", oracle: "LookupTableFlag_39", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_39" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_40", oracle: "LookupTableFlag_40", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_40" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_0", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_0" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_1", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_1" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_2", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_2" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_3", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_3" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_4", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_4" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_5", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_5" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_6", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_6" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_7", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_7" },
-    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRafFlag", oracle: "InstructionRafFlag", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.InstructionRafFlag" },
-    Stage5OpeningClaimPlan { symbol: "stage5.ram_ra_claim_reduction.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.ram_ra_claim_reduction.point.RamRa", eval_source: "stage5.ram_ra_claim_reduction.eval.RamRa" },
-    Stage5OpeningClaimPlan { symbol: "stage5.registers_val_evaluation.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage5.registers_val_evaluation.instance", eval_source: "stage5.registers_val_evaluation.eval.RdInc" },
-    Stage5OpeningClaimPlan { symbol: "stage5.registers_val_evaluation.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage5.registers_val_evaluation.point.RdWa", eval_source: "stage5.registers_val_evaluation.eval.RdWa" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_0" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_1", oracle: "LookupTableFlag_1", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_1" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_2", oracle: "LookupTableFlag_2", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_2" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_3", oracle: "LookupTableFlag_3", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_3" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_4", oracle: "LookupTableFlag_4", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_4" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_5", oracle: "LookupTableFlag_5", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_5" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_6", oracle: "LookupTableFlag_6", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_6" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_7", oracle: "LookupTableFlag_7", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_7" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_8", oracle: "LookupTableFlag_8", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_8" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_9", oracle: "LookupTableFlag_9", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_9" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_10", oracle: "LookupTableFlag_10", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_10" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_11", oracle: "LookupTableFlag_11", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_11" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_12", oracle: "LookupTableFlag_12", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_12" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_13", oracle: "LookupTableFlag_13", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_13" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_14", oracle: "LookupTableFlag_14", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_14" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_15", oracle: "LookupTableFlag_15", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_15" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_16", oracle: "LookupTableFlag_16", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_16" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_17", oracle: "LookupTableFlag_17", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_17" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_18", oracle: "LookupTableFlag_18", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_18" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_19", oracle: "LookupTableFlag_19", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_19" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_20", oracle: "LookupTableFlag_20", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_20" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_21", oracle: "LookupTableFlag_21", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_21" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_22", oracle: "LookupTableFlag_22", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_22" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_23", oracle: "LookupTableFlag_23", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_23" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_24", oracle: "LookupTableFlag_24", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_24" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_25", oracle: "LookupTableFlag_25", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_25" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_26", oracle: "LookupTableFlag_26", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_26" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_27", oracle: "LookupTableFlag_27", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_27" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_28", oracle: "LookupTableFlag_28", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_28" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_29", oracle: "LookupTableFlag_29", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_29" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_30", oracle: "LookupTableFlag_30", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_30" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_31", oracle: "LookupTableFlag_31", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_31" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_32", oracle: "LookupTableFlag_32", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_32" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_33", oracle: "LookupTableFlag_33", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_33" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_34", oracle: "LookupTableFlag_34", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_34" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_35", oracle: "LookupTableFlag_35", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_35" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_36", oracle: "LookupTableFlag_36", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_36" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_37", oracle: "LookupTableFlag_37", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_37" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_38", oracle: "LookupTableFlag_38", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_38" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_39", oracle: "LookupTableFlag_39", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_39" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_40", oracle: "LookupTableFlag_40", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_40" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_0", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_0" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_1", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_1" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_2", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_2" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_3", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_3" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_4", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_4" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_5", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_5" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_6", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_6" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_7", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_7" },
+    Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRafFlag", oracle: "InstructionRafFlag", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.InstructionRafFlag" },
+    Stage5OpeningClaimPlan { symbol: "stage5.ram_ra_claim_reduction.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.ram_ra_claim_reduction.point.RamRa", eval_source: "stage5.ram_ra_claim_reduction.eval.RamRa" },
+    Stage5OpeningClaimPlan { symbol: "stage5.registers_val_evaluation.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Committed, point_source: "stage5.registers_val_evaluation.instance", eval_source: "stage5.registers_val_evaluation.eval.RdInc" },
+    Stage5OpeningClaimPlan { symbol: "stage5.registers_val_evaluation.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.registers_val_evaluation.point.RdWa", eval_source: "stage5.registers_val_evaluation.eval.RdWa" },
 ];
 
 pub const STAGE5_OPENING_EQUALITIES: &[Stage5OpeningClaimEqualityPlan] = &[
-    Stage5OpeningClaimEqualityPlan { symbol: "stage5.instruction.lookup_output_claim_consistency", mode: "point_and_eval", lhs: "stage5.input.stage2.instruction.LookupOutput", rhs: "stage5.input.stage2.product_virtual.LookupOutput" },
+    Stage5OpeningClaimEqualityPlan { symbol: "stage5.instruction.lookup_output_claim_consistency", mode: Stage5OpeningEqualityMode::PointAndEval, lhs: "stage5.input.stage2.instruction.LookupOutput", rhs: "stage5.input.stage2.product_virtual.LookupOutput" },
 ];
 
 pub const STAGE5_OPENING_BATCHES: &[Stage5OpeningBatchPlan] = &[
-    Stage5OpeningBatchPlan { symbol: "stage5.openings", stage: "stage5", proof_slot: "stage5.openings", policy: "jolt_stage5_output_order", count: 53, ordered_claims: "stage5.instruction_read_raf.opening.LookupTableFlag_0|stage5.instruction_read_raf.opening.LookupTableFlag_1|stage5.instruction_read_raf.opening.LookupTableFlag_2|stage5.instruction_read_raf.opening.LookupTableFlag_3|stage5.instruction_read_raf.opening.LookupTableFlag_4|stage5.instruction_read_raf.opening.LookupTableFlag_5|stage5.instruction_read_raf.opening.LookupTableFlag_6|stage5.instruction_read_raf.opening.LookupTableFlag_7|stage5.instruction_read_raf.opening.LookupTableFlag_8|stage5.instruction_read_raf.opening.LookupTableFlag_9|stage5.instruction_read_raf.opening.LookupTableFlag_10|stage5.instruction_read_raf.opening.LookupTableFlag_11|stage5.instruction_read_raf.opening.LookupTableFlag_12|stage5.instruction_read_raf.opening.LookupTableFlag_13|stage5.instruction_read_raf.opening.LookupTableFlag_14|stage5.instruction_read_raf.opening.LookupTableFlag_15|stage5.instruction_read_raf.opening.LookupTableFlag_16|stage5.instruction_read_raf.opening.LookupTableFlag_17|stage5.instruction_read_raf.opening.LookupTableFlag_18|stage5.instruction_read_raf.opening.LookupTableFlag_19|stage5.instruction_read_raf.opening.LookupTableFlag_20|stage5.instruction_read_raf.opening.LookupTableFlag_21|stage5.instruction_read_raf.opening.LookupTableFlag_22|stage5.instruction_read_raf.opening.LookupTableFlag_23|stage5.instruction_read_raf.opening.LookupTableFlag_24|stage5.instruction_read_raf.opening.LookupTableFlag_25|stage5.instruction_read_raf.opening.LookupTableFlag_26|stage5.instruction_read_raf.opening.LookupTableFlag_27|stage5.instruction_read_raf.opening.LookupTableFlag_28|stage5.instruction_read_raf.opening.LookupTableFlag_29|stage5.instruction_read_raf.opening.LookupTableFlag_30|stage5.instruction_read_raf.opening.LookupTableFlag_31|stage5.instruction_read_raf.opening.LookupTableFlag_32|stage5.instruction_read_raf.opening.LookupTableFlag_33|stage5.instruction_read_raf.opening.LookupTableFlag_34|stage5.instruction_read_raf.opening.LookupTableFlag_35|stage5.instruction_read_raf.opening.LookupTableFlag_36|stage5.instruction_read_raf.opening.LookupTableFlag_37|stage5.instruction_read_raf.opening.LookupTableFlag_38|stage5.instruction_read_raf.opening.LookupTableFlag_39|stage5.instruction_read_raf.opening.LookupTableFlag_40|stage5.instruction_read_raf.opening.InstructionRa_0|stage5.instruction_read_raf.opening.InstructionRa_1|stage5.instruction_read_raf.opening.InstructionRa_2|stage5.instruction_read_raf.opening.InstructionRa_3|stage5.instruction_read_raf.opening.InstructionRa_4|stage5.instruction_read_raf.opening.InstructionRa_5|stage5.instruction_read_raf.opening.InstructionRa_6|stage5.instruction_read_raf.opening.InstructionRa_7|stage5.instruction_read_raf.opening.InstructionRafFlag|stage5.ram_ra_claim_reduction.opening.RamRa|stage5.registers_val_evaluation.opening.RdInc|stage5.registers_val_evaluation.opening.RdWa", claim_operands: "stage5.instruction_read_raf.opening.LookupTableFlag_0|stage5.instruction_read_raf.opening.LookupTableFlag_1|stage5.instruction_read_raf.opening.LookupTableFlag_2|stage5.instruction_read_raf.opening.LookupTableFlag_3|stage5.instruction_read_raf.opening.LookupTableFlag_4|stage5.instruction_read_raf.opening.LookupTableFlag_5|stage5.instruction_read_raf.opening.LookupTableFlag_6|stage5.instruction_read_raf.opening.LookupTableFlag_7|stage5.instruction_read_raf.opening.LookupTableFlag_8|stage5.instruction_read_raf.opening.LookupTableFlag_9|stage5.instruction_read_raf.opening.LookupTableFlag_10|stage5.instruction_read_raf.opening.LookupTableFlag_11|stage5.instruction_read_raf.opening.LookupTableFlag_12|stage5.instruction_read_raf.opening.LookupTableFlag_13|stage5.instruction_read_raf.opening.LookupTableFlag_14|stage5.instruction_read_raf.opening.LookupTableFlag_15|stage5.instruction_read_raf.opening.LookupTableFlag_16|stage5.instruction_read_raf.opening.LookupTableFlag_17|stage5.instruction_read_raf.opening.LookupTableFlag_18|stage5.instruction_read_raf.opening.LookupTableFlag_19|stage5.instruction_read_raf.opening.LookupTableFlag_20|stage5.instruction_read_raf.opening.LookupTableFlag_21|stage5.instruction_read_raf.opening.LookupTableFlag_22|stage5.instruction_read_raf.opening.LookupTableFlag_23|stage5.instruction_read_raf.opening.LookupTableFlag_24|stage5.instruction_read_raf.opening.LookupTableFlag_25|stage5.instruction_read_raf.opening.LookupTableFlag_26|stage5.instruction_read_raf.opening.LookupTableFlag_27|stage5.instruction_read_raf.opening.LookupTableFlag_28|stage5.instruction_read_raf.opening.LookupTableFlag_29|stage5.instruction_read_raf.opening.LookupTableFlag_30|stage5.instruction_read_raf.opening.LookupTableFlag_31|stage5.instruction_read_raf.opening.LookupTableFlag_32|stage5.instruction_read_raf.opening.LookupTableFlag_33|stage5.instruction_read_raf.opening.LookupTableFlag_34|stage5.instruction_read_raf.opening.LookupTableFlag_35|stage5.instruction_read_raf.opening.LookupTableFlag_36|stage5.instruction_read_raf.opening.LookupTableFlag_37|stage5.instruction_read_raf.opening.LookupTableFlag_38|stage5.instruction_read_raf.opening.LookupTableFlag_39|stage5.instruction_read_raf.opening.LookupTableFlag_40|stage5.instruction_read_raf.opening.InstructionRa_0|stage5.instruction_read_raf.opening.InstructionRa_1|stage5.instruction_read_raf.opening.InstructionRa_2|stage5.instruction_read_raf.opening.InstructionRa_3|stage5.instruction_read_raf.opening.InstructionRa_4|stage5.instruction_read_raf.opening.InstructionRa_5|stage5.instruction_read_raf.opening.InstructionRa_6|stage5.instruction_read_raf.opening.InstructionRa_7|stage5.instruction_read_raf.opening.InstructionRafFlag|stage5.ram_ra_claim_reduction.opening.RamRa|stage5.registers_val_evaluation.opening.RdInc|stage5.registers_val_evaluation.opening.RdWa" },
+    Stage5OpeningBatchPlan { symbol: "stage5.openings", stage: "stage5", proof_slot: "stage5.openings", policy: "jolt_stage5_output_order", count: 53, ordered_claims: &["stage5.instruction_read_raf.opening.LookupTableFlag_0", "stage5.instruction_read_raf.opening.LookupTableFlag_1", "stage5.instruction_read_raf.opening.LookupTableFlag_2", "stage5.instruction_read_raf.opening.LookupTableFlag_3", "stage5.instruction_read_raf.opening.LookupTableFlag_4", "stage5.instruction_read_raf.opening.LookupTableFlag_5", "stage5.instruction_read_raf.opening.LookupTableFlag_6", "stage5.instruction_read_raf.opening.LookupTableFlag_7", "stage5.instruction_read_raf.opening.LookupTableFlag_8", "stage5.instruction_read_raf.opening.LookupTableFlag_9", "stage5.instruction_read_raf.opening.LookupTableFlag_10", "stage5.instruction_read_raf.opening.LookupTableFlag_11", "stage5.instruction_read_raf.opening.LookupTableFlag_12", "stage5.instruction_read_raf.opening.LookupTableFlag_13", "stage5.instruction_read_raf.opening.LookupTableFlag_14", "stage5.instruction_read_raf.opening.LookupTableFlag_15", "stage5.instruction_read_raf.opening.LookupTableFlag_16", "stage5.instruction_read_raf.opening.LookupTableFlag_17", "stage5.instruction_read_raf.opening.LookupTableFlag_18", "stage5.instruction_read_raf.opening.LookupTableFlag_19", "stage5.instruction_read_raf.opening.LookupTableFlag_20", "stage5.instruction_read_raf.opening.LookupTableFlag_21", "stage5.instruction_read_raf.opening.LookupTableFlag_22", "stage5.instruction_read_raf.opening.LookupTableFlag_23", "stage5.instruction_read_raf.opening.LookupTableFlag_24", "stage5.instruction_read_raf.opening.LookupTableFlag_25", "stage5.instruction_read_raf.opening.LookupTableFlag_26", "stage5.instruction_read_raf.opening.LookupTableFlag_27", "stage5.instruction_read_raf.opening.LookupTableFlag_28", "stage5.instruction_read_raf.opening.LookupTableFlag_29", "stage5.instruction_read_raf.opening.LookupTableFlag_30", "stage5.instruction_read_raf.opening.LookupTableFlag_31", "stage5.instruction_read_raf.opening.LookupTableFlag_32", "stage5.instruction_read_raf.opening.LookupTableFlag_33", "stage5.instruction_read_raf.opening.LookupTableFlag_34", "stage5.instruction_read_raf.opening.LookupTableFlag_35", "stage5.instruction_read_raf.opening.LookupTableFlag_36", "stage5.instruction_read_raf.opening.LookupTableFlag_37", "stage5.instruction_read_raf.opening.LookupTableFlag_38", "stage5.instruction_read_raf.opening.LookupTableFlag_39", "stage5.instruction_read_raf.opening.LookupTableFlag_40", "stage5.instruction_read_raf.opening.InstructionRa_0", "stage5.instruction_read_raf.opening.InstructionRa_1", "stage5.instruction_read_raf.opening.InstructionRa_2", "stage5.instruction_read_raf.opening.InstructionRa_3", "stage5.instruction_read_raf.opening.InstructionRa_4", "stage5.instruction_read_raf.opening.InstructionRa_5", "stage5.instruction_read_raf.opening.InstructionRa_6", "stage5.instruction_read_raf.opening.InstructionRa_7", "stage5.instruction_read_raf.opening.InstructionRafFlag", "stage5.ram_ra_claim_reduction.opening.RamRa", "stage5.registers_val_evaluation.opening.RdInc", "stage5.registers_val_evaluation.opening.RdWa"], claim_operands: &["stage5.instruction_read_raf.opening.LookupTableFlag_0", "stage5.instruction_read_raf.opening.LookupTableFlag_1", "stage5.instruction_read_raf.opening.LookupTableFlag_2", "stage5.instruction_read_raf.opening.LookupTableFlag_3", "stage5.instruction_read_raf.opening.LookupTableFlag_4", "stage5.instruction_read_raf.opening.LookupTableFlag_5", "stage5.instruction_read_raf.opening.LookupTableFlag_6", "stage5.instruction_read_raf.opening.LookupTableFlag_7", "stage5.instruction_read_raf.opening.LookupTableFlag_8", "stage5.instruction_read_raf.opening.LookupTableFlag_9", "stage5.instruction_read_raf.opening.LookupTableFlag_10", "stage5.instruction_read_raf.opening.LookupTableFlag_11", "stage5.instruction_read_raf.opening.LookupTableFlag_12", "stage5.instruction_read_raf.opening.LookupTableFlag_13", "stage5.instruction_read_raf.opening.LookupTableFlag_14", "stage5.instruction_read_raf.opening.LookupTableFlag_15", "stage5.instruction_read_raf.opening.LookupTableFlag_16", "stage5.instruction_read_raf.opening.LookupTableFlag_17", "stage5.instruction_read_raf.opening.LookupTableFlag_18", "stage5.instruction_read_raf.opening.LookupTableFlag_19", "stage5.instruction_read_raf.opening.LookupTableFlag_20", "stage5.instruction_read_raf.opening.LookupTableFlag_21", "stage5.instruction_read_raf.opening.LookupTableFlag_22", "stage5.instruction_read_raf.opening.LookupTableFlag_23", "stage5.instruction_read_raf.opening.LookupTableFlag_24", "stage5.instruction_read_raf.opening.LookupTableFlag_25", "stage5.instruction_read_raf.opening.LookupTableFlag_26", "stage5.instruction_read_raf.opening.LookupTableFlag_27", "stage5.instruction_read_raf.opening.LookupTableFlag_28", "stage5.instruction_read_raf.opening.LookupTableFlag_29", "stage5.instruction_read_raf.opening.LookupTableFlag_30", "stage5.instruction_read_raf.opening.LookupTableFlag_31", "stage5.instruction_read_raf.opening.LookupTableFlag_32", "stage5.instruction_read_raf.opening.LookupTableFlag_33", "stage5.instruction_read_raf.opening.LookupTableFlag_34", "stage5.instruction_read_raf.opening.LookupTableFlag_35", "stage5.instruction_read_raf.opening.LookupTableFlag_36", "stage5.instruction_read_raf.opening.LookupTableFlag_37", "stage5.instruction_read_raf.opening.LookupTableFlag_38", "stage5.instruction_read_raf.opening.LookupTableFlag_39", "stage5.instruction_read_raf.opening.LookupTableFlag_40", "stage5.instruction_read_raf.opening.InstructionRa_0", "stage5.instruction_read_raf.opening.InstructionRa_1", "stage5.instruction_read_raf.opening.InstructionRa_2", "stage5.instruction_read_raf.opening.InstructionRa_3", "stage5.instruction_read_raf.opening.InstructionRa_4", "stage5.instruction_read_raf.opening.InstructionRa_5", "stage5.instruction_read_raf.opening.InstructionRa_6", "stage5.instruction_read_raf.opening.InstructionRa_7", "stage5.instruction_read_raf.opening.InstructionRafFlag", "stage5.ram_ra_claim_reduction.opening.RamRa", "stage5.registers_val_evaluation.opening.RdInc", "stage5.registers_val_evaluation.opening.RdWa"] },
+];
+#[rustfmt::skip]
+const STAGE5_INDEXED_EVAL_FAMILY_0_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.LookupTableFlag_0", "stage5.instruction_read_raf.eval.LookupTableFlag_1", "stage5.instruction_read_raf.eval.LookupTableFlag_2", "stage5.instruction_read_raf.eval.LookupTableFlag_3", "stage5.instruction_read_raf.eval.LookupTableFlag_4", "stage5.instruction_read_raf.eval.LookupTableFlag_5", "stage5.instruction_read_raf.eval.LookupTableFlag_6", "stage5.instruction_read_raf.eval.LookupTableFlag_7", "stage5.instruction_read_raf.eval.LookupTableFlag_8", "stage5.instruction_read_raf.eval.LookupTableFlag_9", "stage5.instruction_read_raf.eval.LookupTableFlag_10", "stage5.instruction_read_raf.eval.LookupTableFlag_11", "stage5.instruction_read_raf.eval.LookupTableFlag_12", "stage5.instruction_read_raf.eval.LookupTableFlag_13", "stage5.instruction_read_raf.eval.LookupTableFlag_14", "stage5.instruction_read_raf.eval.LookupTableFlag_15", "stage5.instruction_read_raf.eval.LookupTableFlag_16", "stage5.instruction_read_raf.eval.LookupTableFlag_17", "stage5.instruction_read_raf.eval.LookupTableFlag_18", "stage5.instruction_read_raf.eval.LookupTableFlag_19", "stage5.instruction_read_raf.eval.LookupTableFlag_20", "stage5.instruction_read_raf.eval.LookupTableFlag_21", "stage5.instruction_read_raf.eval.LookupTableFlag_22", "stage5.instruction_read_raf.eval.LookupTableFlag_23", "stage5.instruction_read_raf.eval.LookupTableFlag_24", "stage5.instruction_read_raf.eval.LookupTableFlag_25", "stage5.instruction_read_raf.eval.LookupTableFlag_26", "stage5.instruction_read_raf.eval.LookupTableFlag_27", "stage5.instruction_read_raf.eval.LookupTableFlag_28", "stage5.instruction_read_raf.eval.LookupTableFlag_29", "stage5.instruction_read_raf.eval.LookupTableFlag_30", "stage5.instruction_read_raf.eval.LookupTableFlag_31", "stage5.instruction_read_raf.eval.LookupTableFlag_32", "stage5.instruction_read_raf.eval.LookupTableFlag_33", "stage5.instruction_read_raf.eval.LookupTableFlag_34", "stage5.instruction_read_raf.eval.LookupTableFlag_35", "stage5.instruction_read_raf.eval.LookupTableFlag_36", "stage5.instruction_read_raf.eval.LookupTableFlag_37", "stage5.instruction_read_raf.eval.LookupTableFlag_38", "stage5.instruction_read_raf.eval.LookupTableFlag_39", "stage5.instruction_read_raf.eval.LookupTableFlag_40"];
+#[rustfmt::skip]
+const STAGE5_INDEXED_EVAL_FAMILY_1_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_1", "stage5.instruction_read_raf.eval.InstructionRa_2", "stage5.instruction_read_raf.eval.InstructionRa_3", "stage5.instruction_read_raf.eval.InstructionRa_4", "stage5.instruction_read_raf.eval.InstructionRa_5", "stage5.instruction_read_raf.eval.InstructionRa_6", "stage5.instruction_read_raf.eval.InstructionRa_7"];
+pub const STAGE5_INDEXED_EVAL_FAMILIES: &[bolt_verifier_runtime::NamedEvalFamilyPlan] = &[
+    bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.LookupTableFlag", evals: STAGE5_INDEXED_EVAL_FAMILY_0_NAMES },
+    bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INDEXED_EVAL_FAMILY_1_NAMES },
+];
+
+pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.local_scalar.LookupTable_0", "stage5.instruction_read_raf.local_scalar.LookupTable_1", "stage5.instruction_read_raf.local_scalar.LookupTable_2", "stage5.instruction_read_raf.local_scalar.LookupTable_3", "stage5.instruction_read_raf.local_scalar.LookupTable_4", "stage5.instruction_read_raf.local_scalar.LookupTable_5", "stage5.instruction_read_raf.local_scalar.LookupTable_6", "stage5.instruction_read_raf.local_scalar.LookupTable_7", "stage5.instruction_read_raf.local_scalar.LookupTable_8", "stage5.instruction_read_raf.local_scalar.LookupTable_9", "stage5.instruction_read_raf.local_scalar.LookupTable_10", "stage5.instruction_read_raf.local_scalar.LookupTable_11", "stage5.instruction_read_raf.local_scalar.LookupTable_12", "stage5.instruction_read_raf.local_scalar.LookupTable_13", "stage5.instruction_read_raf.local_scalar.LookupTable_14", "stage5.instruction_read_raf.local_scalar.LookupTable_15", "stage5.instruction_read_raf.local_scalar.LookupTable_16", "stage5.instruction_read_raf.local_scalar.LookupTable_17", "stage5.instruction_read_raf.local_scalar.LookupTable_18", "stage5.instruction_read_raf.local_scalar.LookupTable_19", "stage5.instruction_read_raf.local_scalar.LookupTable_20", "stage5.instruction_read_raf.local_scalar.LookupTable_21", "stage5.instruction_read_raf.local_scalar.LookupTable_22", "stage5.instruction_read_raf.local_scalar.LookupTable_23", "stage5.instruction_read_raf.local_scalar.LookupTable_24", "stage5.instruction_read_raf.local_scalar.LookupTable_25", "stage5.instruction_read_raf.local_scalar.LookupTable_26", "stage5.instruction_read_raf.local_scalar.LookupTable_27", "stage5.instruction_read_raf.local_scalar.LookupTable_28", "stage5.instruction_read_raf.local_scalar.LookupTable_29", "stage5.instruction_read_raf.local_scalar.LookupTable_30", "stage5.instruction_read_raf.local_scalar.LookupTable_31", "stage5.instruction_read_raf.local_scalar.LookupTable_32", "stage5.instruction_read_raf.local_scalar.LookupTable_33", "stage5.instruction_read_raf.local_scalar.LookupTable_34", "stage5.instruction_read_raf.local_scalar.LookupTable_35", "stage5.instruction_read_raf.local_scalar.LookupTable_36", "stage5.instruction_read_raf.local_scalar.LookupTable_37", "stage5.instruction_read_raf.local_scalar.LookupTable_38", "stage5.instruction_read_raf.local_scalar.LookupTable_39", "stage5.instruction_read_raf.local_scalar.LookupTable_40", "stage5.instruction_read_raf.local_scalar.LeftLookupOperand", "stage5.instruction_read_raf.local_scalar.RightLookupOperand", "stage5.instruction_read_raf.local_scalar.Identity"];
+pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[
+    Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" },
+    Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" },
+    Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" },
 ];
-pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan {
-    role: "verifier",
-    params: STAGE5_PARAMS,
-    steps: STAGE5_PROGRAM_STEPS,
-    transcript_squeezes: STAGE5_TRANSCRIPT_SQUEEZES,
-    transcript_absorb_bytes: STAGE5_TRANSCRIPT_ABSORB_BYTES,
-    opening_inputs: STAGE5_OPENING_INPUTS,
-    field_constants: STAGE5_FIELD_CONSTANTS,
-    field_exprs: STAGE5_FIELD_EXPRS,
-    kernels: STAGE5_KERNELS,
-    claims: STAGE5_SUMCHECK_CLAIMS,
-    batches: STAGE5_SUMCHECK_BATCHES,
-    drivers: STAGE5_SUMCHECK_DRIVERS,
-    instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,
-    evals: STAGE5_SUMCHECK_EVALS,
-    point_slices: STAGE5_POINT_SLICES,
-    point_concats: STAGE5_POINT_CONCATS,
-    opening_claims: STAGE5_OPENING_CLAIMS,
-    opening_equalities: STAGE5_OPENING_EQUALITIES,
-    opening_batches: STAGE5_OPENING_BATCHES,
+
+pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5VerifierProgramPlan {
+    base: Stage5CpuProgramPlan {
+        role: "verifier",
+        params: STAGE5_PARAMS,
+        steps: STAGE5_PROGRAM_STEPS,
+        transcript_squeezes: STAGE5_TRANSCRIPT_SQUEEZES,
+        transcript_absorb_bytes: STAGE5_TRANSCRIPT_ABSORB_BYTES,
+        opening_inputs: STAGE5_OPENING_INPUTS,
+        field_constants: STAGE5_FIELD_CONSTANTS,
+        field_exprs: STAGE5_FIELD_EXPRS,
+        scalar_exprs: STAGE5_SCALAR_EXPRS,
+        kernels: STAGE5_KERNELS,
+        claims: STAGE5_SUMCHECK_CLAIMS,
+        batches: STAGE5_SUMCHECK_BATCHES,
+        drivers: STAGE5_SUMCHECK_DRIVERS,
+        instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,
+        evals: STAGE5_SUMCHECK_EVALS,
+        indexed_eval_families: STAGE5_INDEXED_EVAL_FAMILIES,
+        relation_outputs: STAGE5_RELATION_OUTPUTS,
+        point_exprs: STAGE5_POINT_EXPRS,
+        opening_claims: STAGE5_OPENING_CLAIMS,
+        opening_equalities: STAGE5_OPENING_EQUALITIES,
+        opening_batches: STAGE5_OPENING_BATCHES,
+    },
+    instruction_read_raf_plan: STAGE5_INSTRUCTION_READ_RAF_PLAN,
 };
 
 pub fn verify_stage5<T>(
@@ -321,19 +477,19 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
     let mut artifacts = Stage5ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage5ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage5Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage5_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "transcript_absorb_bytes" => {
+            Stage5ProgramStepKind::TranscriptAbsorbBytes => {
                 let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or(
                     VerifyStage5Error::MissingValue {
                         symbol: step.symbol,
@@ -341,19 +497,13 @@ where
                 )?;
                 absorb_stage5_bytes(absorb, transcript);
             }
-            "sumcheck_driver" => {
+            Stage5ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage5Error::MissingProof {
                         driver: step.symbol,
                     })?;
                 verify_stage5_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?;
             }
-            _ => {
-                return Err(VerifyStage5Error::InvalidProof {
-                    driver: step.symbol,
-                    reason: "unsupported stage5 program step",
-                });
-            }
         }
     }
     artifacts
@@ -369,7 +519,7 @@ pub fn stage5_verifier_program() -> &'static Stage5VerifierProgramPlan {
 fn verify_stage5_squeeze<T>(
     program: &'static Stage5VerifierProgramPlan,
     squeeze: &'static Stage5TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage5ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage5Error>
@@ -385,7 +535,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage5Error::from)?;
     artifacts.challenge_vectors.push(Stage5ChallengeVector {
         symbol: squeeze.symbol,
@@ -409,7 +559,7 @@ fn verify_stage5_driver<T>(
     program: &'static Stage5VerifierProgramPlan,
     driver: &'static Stage5SumcheckDriverPlan,
     proof: &Stage5Proof<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage5ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage5Error>
@@ -422,12 +572,17 @@ where
         .ok_or(VerifyStage5Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage5Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage5.batched" => {
+        Stage5RelationKind::Stage5Batched => {
             verify_batched_stage5(program, driver, proof, store, transcript)?
         }
-        _ => return Err(VerifyStage5Error::UnsupportedRelation { relation }),
+        relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -437,25 +592,50 @@ fn verify_batched_stage5<T>(
     program: &'static Stage5VerifierProgramPlan,
     driver: &'static Stage5SumcheckDriverPlan,
     proof: &Stage5SumcheckOutput<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage5SumcheckOutput<Fr>, VerifyStage5Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage5Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs)
+            bolt_verifier_runtime::evaluate_relation_output_batch(
+                driver,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                program.indexed_eval_families,
+                store,
+                evals,
+                point,
+                batching_coeffs,
+                |instance, relation_output, local_point| {
+                    stage5_relation_output_inputs(program, instance, relation_output, local_point)
+                },
+            )
         },
         |store, verified| observe_stage5_sumcheck_output(program, store, verified),
         |driver, error| VerifyStage5Error::Sumcheck { driver, error },
@@ -464,7 +644,7 @@ where
 
 fn observe_stage5_sumcheck_output<F: Field>(
     program: &'static Stage5VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage5SumcheckOutput<F>,
 ) -> Result<(), VerifyStage5Error> {
     store.observe_sumcheck_output(
@@ -473,17 +653,17 @@ fn observe_stage5_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                "instruction_read_raf" => {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
+                    if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf {
+                        return Err(VerifyStage5Error::InvalidProof {
+                            driver: output.driver,
+                            reason: "unsupported relation-local point order",
+                        });
+                    }
                     point = normalize_instruction_read_raf_point(&point, "stage5.instruction_read_raf.point")?;
                 }
-                _ => {
-                    return Err(VerifyStage5Error::InvalidProof {
-                        driver: output.driver,
-                        reason: "unsupported point order",
-                    });
-                }
             }
             Ok(point)
         },
@@ -494,9 +674,9 @@ fn observe_stage5_sumcheck_output<F: Field>(
         },
         |symbol| VerifyStage5Error::MissingValue { symbol },
     )?;
+    store.evaluate_named_eval_families(program.indexed_eval_families)?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage5Error::InvalidInputLength {
             input,
             expected,
@@ -504,7 +684,7 @@ fn observe_stage5_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage5Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -513,152 +693,24 @@ fn observe_stage5_sumcheck_output<F: Field>(
     )
 }
 
-fn expected_batched_output_claim(
+fn stage5_relation_output_inputs<'a>(
     program: &'static Stage5VerifierProgramPlan,
-    driver: &'static Stage5SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage5NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage5Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage5Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage5Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let relation = claim.relation.unwrap_or("<missing>");
-        let value = match relation {
-            "jolt.stage5.instruction_read_raf" => {
-                expected_instruction_read_raf(store, evals, local_point)?
-            }
-            "jolt.stage5.ram_ra_claim_reduction" => {
-                expected_ram_ra_claim_reduction(store, evals, local_point)?
-            }
-            "jolt.stage5.registers_val_evaluation" => {
-                expected_registers_val_evaluation(store, evals, local_point)?
-            }
-            _ => return Err(VerifyStage5Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_instruction_read_raf(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage5NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage5Error> {
-    const LOG_K: usize = 128;
-    const XLEN: usize = 64;
-
-    if local_point.len() < LOG_K {
-        return Err(VerifyStage5Error::InvalidInputLength {
-            input: "stage5.instruction_read_raf.point",
-            expected: LOG_K,
-            actual: local_point.len(),
-        });
+    instance: &Stage5SumcheckInstanceResultPlan,
+    relation_output: &Stage5RelationOutputPlan,
+    local_point: &'a [Fr],
+) -> Result<bolt_verifier_runtime::RelationOutputInputs<'a, Fr>, VerifyStage5Error> {
+    if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf {
+        return Ok(bolt_verifier_runtime::RelationOutputInputs::empty());
     }
 
-    let (r_address_prime, r_cycle) = local_point.split_at(LOG_K);
-    let r_cycle_prime = reverse_slice(r_cycle);
-    let r_reduction = super::common::store_point(store, "stage5.input.stage2.instruction.LookupOutput")?;
-    let eq_eval_r_reduction = EqPolynomial::<Fr>::mle(r_reduction, &r_cycle_prime);
-
-    let left_operand_eval = operand_polynomial_eval(r_address_prime, true);
-    let right_operand_eval = operand_polynomial_eval(r_address_prime, false);
-    let identity_poly_eval = identity_polynomial_eval(r_address_prime);
-
-    let table_flag_claims = indexed_evals_by_prefix_any(
-        evals,
-        "stage5.instruction_read_raf.eval.LookupTableFlag_",
-    )?;
-    let table_values = LookupTableKind::<XLEN>::all()
-        .iter()
-        .take(table_flag_claims.len())
-        .map(|table| table.evaluate_mle::<Fr, Fr>(r_address_prime))
-        .collect::<Vec<_>>();
-    let val_claim = table_values
-        .into_iter()
-        .zip(table_flag_claims)
-        .map(|(table_value, flag_claim)| table_value * flag_claim)
-        .sum::<Fr>();
-
-    let ra_claim = indexed_evals_by_prefix_any(
-        evals,
-        "stage5.instruction_read_raf.eval.InstructionRa_",
-    )?
-    .into_iter()
-    .product::<Fr>();
-    let raf_flag_claim = eval_by_name(
-        evals,
-        "stage5.instruction_read_raf.eval.InstructionRafFlag",
-    )?;
-    let gamma = super::common::store_scalar(store, "stage5.instruction_read_raf.gamma")?;
-
-    let raf_claim = (Fr::from_u64(1) - raf_flag_claim)
-        * (left_operand_eval + gamma * right_operand_eval)
-        + raf_flag_claim * gamma * identity_poly_eval;
-    Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim))
-}
-
-fn expected_ram_ra_claim_reduction(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage5NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage5Error> {
-    let r_cycle_reduced = reverse_slice(local_point);
-    let r_cycle_raf = suffix_point(
-        super::common::store_point(store, "stage5.input.stage2.ram_raf.RamRa")?,
-        r_cycle_reduced.len(),
-        "stage5.input.stage2.ram_raf.RamRa",
-    )?;
-    let r_cycle_rw = suffix_point(
-        super::common::store_point(store, "stage5.input.stage2.ram_read_write.RamRa")?,
-        r_cycle_reduced.len(),
-        "stage5.input.stage2.ram_read_write.RamRa",
-    )?;
-    let r_cycle_val = suffix_point(
-        super::common::store_point(store, "stage5.input.stage4.ram_val_check.RamRa")?,
-        r_cycle_reduced.len(),
-        "stage5.input.stage4.ram_val_check.RamRa",
-    )?;
-    let gamma = super::common::store_scalar(store, "stage5.ram_ra_claim_reduction.gamma")?;
-    let eq_combined = EqPolynomial::<Fr>::mle(r_cycle_raf, &r_cycle_reduced)
-        + gamma * EqPolynomial::<Fr>::mle(r_cycle_rw, &r_cycle_reduced)
-        + gamma.square() * EqPolynomial::<Fr>::mle(r_cycle_val, &r_cycle_reduced);
-    let ram_ra = eval_by_name(evals, "stage5.ram_ra_claim_reduction.eval.RamRa")?;
-    Ok(eq_combined * ram_ra)
-}
-
-fn expected_registers_val_evaluation(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage5NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage5Error> {
-    let registers_val_point = super::common::store_point(store, "stage5.input.stage4.registers.RegistersVal")?;
-    let r_cycle = suffix_point(
-        registers_val_point,
-        local_point.len(),
-        "stage5.input.stage4.registers.RegistersVal",
-    )?;
-    let r_reduced = reverse_slice(local_point);
-    let lt_eval = lt_polynomial_eval(&r_reduced, r_cycle);
-    let rd_inc = eval_by_name(evals, "stage5.registers_val_evaluation.eval.RdInc")?;
-    let rd_wa = eval_by_name(evals, "stage5.registers_val_evaluation.eval.RdWa")?;
-    Ok(rd_inc * rd_wa * lt_eval)
+    Ok(bolt_verifier_runtime::RelationOutputInputs {
+        scalars: bolt_verifier_runtime::select_named_scalars(
+            relation_output.local_scalars,
+            evaluate_stage5_instruction_read_raf_local_scalars(
+                &program.instruction_read_raf_plan,
+                local_point,
+            )?,
+        )?,
+        points: Vec::new(),
+    })
 }
diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs
index df9438b3fe..564f4f2c95 100644
--- a/crates/jolt-verifier/src/stages/stage6.rs
+++ b/crates/jolt-verifier/src/stages/stage6.rs
@@ -1,35 +1,59 @@
 #![allow(dead_code)]
 
-use super::common::{batch_claims, expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, find_batch, find_plan, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};
+use bolt_verifier_runtime::find_plan;
+use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_scalars, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};
 use jolt_field::{Field, Fr};
 use jolt_sumcheck::SumcheckError;
 use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};
 
-pub type Stage6NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage6SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage6ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage6ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage6Proof<F> = super::common::StageProof<F>;
-pub type Stage6OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-
-pub use super::common::{
-    FieldConstantPlan as Stage6FieldConstantPlan, FieldExprPlan as Stage6FieldExprPlan,
+pub type Stage6NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage6SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage6ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage6ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage6Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage6OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage6CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan<Stage6RelationKind>;
+pub type Stage6SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage6RelationKind>;
+pub type Stage6SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage6RelationKind>;
+pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage6RelationKind>;
+pub type Stage6RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage6RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage6ClaimKind, FieldConstantPlan as Stage6FieldConstantPlan,
+    FieldExprKind as Stage6FieldExprKind,
+    FieldExprPlan as Stage6FieldExprPlan,
+    ScalarExprKind as Stage6ScalarExprKind,
+    ScalarExprPlan as Stage6ScalarExprPlan,
     KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan,
-    PointConcatPlan as Stage6PointConcatPlan, PointSlicePlan as Stage6PointSlicePlan,
-    PointZeroPlan as Stage6PointZeroPlan, ProgramStepPlan as Stage6ProgramStepPlan,
-    StageParams as Stage6Params, StageProgramPlan as Stage6CpuProgramPlan,
+    OpeningEqualityMode as Stage6OpeningEqualityMode, PointExprKind as Stage6PointExprKind,
+    PointExprPlan as Stage6PointExprPlan, ProgramStepKind as Stage6ProgramStepKind,
+    ProgramStepPlan as Stage6ProgramStepPlan,
+    StageParams as Stage6Params,
     SumcheckBatchPlan as Stage6SumcheckBatchPlan,
-    SumcheckClaimPlan as Stage6SumcheckClaimPlan, SumcheckDriverPlan as Stage6SumcheckDriverPlan,
     SumcheckEvalPlan as Stage6SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage6SumcheckInstanceResultPlan,
     TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan,
+    TranscriptSqueezeKind as Stage6TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage6TranscriptSqueezePlan,
 };
 
 pub type DefaultStage6Transcript = Blake2bTranscript<Fr>;
-pub type Stage6VerifierProgramPlan = Stage6CpuProgramPlan;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage6VerifierProgramPlan {
+    pub base: Stage6CpuProgramPlan,
+    pub bytecode_plan: Stage67BytecodeReadRafPlan,
+}
+
+impl core::ops::Deref for Stage6VerifierProgramPlan {
+    type Target = Stage6CpuProgramPlan;
+
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
+}
 
 #[derive(Clone, Debug)]
 pub struct Stage6BytecodeEntry {
@@ -80,58 +104,7 @@ pub struct Stage6VerifierData {
 }
 
 const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols {
-    hamming_booleanity_relation: "jolt.stage6.hamming_booleanity",
     hamming_booleanity_instance: "stage6.hamming_booleanity.instance",
-    booleanity_point: "stage6.booleanity.point",
-    stage5_instruction_ra0: "stage6.input.stage5.instruction_read_raf.InstructionRa_0",
-    booleanity_combined_point: "stage6.booleanity.combined_point",
-    booleanity_gamma: "stage6.booleanity.gamma",
-    booleanity_instruction_ra_prefix: "stage6.booleanity.eval.InstructionRa_",
-    booleanity_bytecode_ra_prefix: "stage6.booleanity.eval.BytecodeRa_",
-    booleanity_ram_ra_prefix: "stage6.booleanity.eval.RamRa_",
-    hamming_weight_eval: "stage6.hamming_booleanity.eval.HammingWeight",
-    hamming_lookup_output: "stage6.input.stage1.LookupOutput",
-    ram_ra_virtual_cycle: "stage6.input.stage5.ram_ra_claim_reduction.RamRa",
-    ram_ra_virtual_eval_prefix: "stage6.ram_ra_virtual.eval.RamRa_",
-    instruction_ra_virtual_cycle: "stage6.input.stage5.instruction_read_raf.InstructionRa_0",
-    instruction_ra_virtual_eval_prefix: "stage6.instruction_ra_virtual.eval.InstructionRa_",
-    instruction_ra_virtual_input_prefix: "stage6.input.stage5.instruction_read_raf.InstructionRa_",
-    instruction_ra_virtual_gamma: "stage6.instruction_ra_virtual.gamma",
-    inc_ram_stage2: "stage6.input.stage2.ram_read_write.RamInc",
-    inc_ram_stage4: "stage6.input.stage4.ram_val_check.RamInc",
-    inc_rd_stage4: "stage6.input.stage4.registers_read_write.RdInc",
-    inc_rd_stage5: "stage6.input.stage5.registers_val_evaluation.RdInc",
-    inc_gamma: "stage6.inc_claim_reduction.gamma",
-    inc_ram_eval: "stage6.inc_claim_reduction.eval.RamInc",
-    inc_rd_eval: "stage6.inc_claim_reduction.eval.RdInc",
-};
-
-const STAGE6_BYTECODE_SYMBOLS: Stage67BytecodeSymbols = Stage67BytecodeSymbols {
-    point: "stage6.bytecode_read_raf.point",
-    gamma: "stage6.bytecode_read_raf.gamma",
-    bytecode_ra_eval_prefix: "stage6.bytecode_read_raf.eval.BytecodeRa_",
-    entries: "stage6.bytecode_read_raf.entries",
-    entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index",
-    stage_gammas: [
-        "stage6.bytecode_read_raf.stage1_gamma",
-        "stage6.bytecode_read_raf.stage2_gamma",
-        "stage6.bytecode_read_raf.stage3_gamma",
-        "stage6.bytecode_read_raf.stage4_gamma",
-        "stage6.bytecode_read_raf.stage5_gamma",
-    ],
-    stage_cycle_points: [
-        "stage6.input.stage1.Imm",
-        "stage6.input.stage2.OpFlagJump",
-        "stage6.input.stage3.spartan_shift.UnexpandedPC",
-        "stage6.input.stage4.Rs1Ra",
-        "stage6.input.stage5.registers_val_evaluation.RdWa",
-    ],
-    stage4_register_point: "stage6.input.stage4.Rs1Ra",
-    stage5_register_point: "stage6.input.stage5.registers_val_evaluation.RdWa",
-    entry_rd: "stage6.bytecode.entry.rd",
-    entry_rs1: "stage6.bytecode.entry.rs1",
-    entry_rs2: "stage6.bytecode.entry.rs2",
-    entry_lookup_table: "stage6.bytecode.entry.lookup_table",
 };
 
 #[derive(Debug)]
@@ -143,41 +116,36 @@ pub enum VerifyStage6Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage6RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error);
 
-pub const STAGE6_PARAMS: Stage6Params = Stage6Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE6_PARAMS: Stage6Params = Stage6Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE6_PROGRAM_STEPS: &[Stage6ProgramStepPlan] = &[
-    Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.gamma" },
-    Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage1_gamma" },
-    Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage2_gamma" },
-    Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage3_gamma" },
-    Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage4_gamma" },
-    Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage5_gamma" },
-    Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.booleanity.gamma" },
-    Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.instruction_ra_virtual.gamma" },
-    Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.inc_claim_reduction.gamma" },
-    Stage6ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage6.sumcheck" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.gamma" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage1_gamma" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage2_gamma" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage3_gamma" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage4_gamma" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage5_gamma" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.booleanity.gamma" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.instruction_ra_virtual.gamma" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.inc_claim_reduction.gamma" },
+    Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::SumcheckDriver, symbol: "stage6.sumcheck" },
 ];
 
 pub const STAGE6_TRANSCRIPT_SQUEEZES: &[Stage6TranscriptSqueezePlan] = &[
-    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.gamma", label: "bc_raf_gamma", kind: "challenge_scalar", count: 1 },
-    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage1_gamma", label: "bc_raf_stage1_gamma", kind: "challenge_scalar", count: 1 },
-    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage2_gamma", label: "bc_raf_stage2_gamma", kind: "challenge_scalar", count: 1 },
-    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage3_gamma", label: "bc_raf_stage3_gamma", kind: "challenge_scalar", count: 1 },
-    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage4_gamma", label: "bc_raf_stage4_gamma", kind: "challenge_scalar", count: 1 },
-    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage5_gamma", label: "bc_raf_stage5_gamma", kind: "challenge_scalar", count: 1 },
-    Stage6TranscriptSqueezePlan { symbol: "stage6.booleanity.gamma", label: "booleanity_gamma", kind: "challenge_scalar", count: 1 },
-    Stage6TranscriptSqueezePlan { symbol: "stage6.instruction_ra_virtual.gamma", label: "inst_ra_virtual_gamma", kind: "challenge_scalar", count: 1 },
-    Stage6TranscriptSqueezePlan { symbol: "stage6.inc_claim_reduction.gamma", label: "inc_reduction_gamma", kind: "challenge_scalar", count: 1 },
+    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.gamma", label: "bc_raf_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage1_gamma", label: "bc_raf_stage1_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage2_gamma", label: "bc_raf_stage2_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage3_gamma", label: "bc_raf_stage3_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage4_gamma", label: "bc_raf_stage4_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage5_gamma", label: "bc_raf_stage5_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage6TranscriptSqueezePlan { symbol: "stage6.booleanity.gamma", label: "booleanity_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage6TranscriptSqueezePlan { symbol: "stage6.instruction_ra_virtual.gamma", label: "inst_ra_virtual_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 },
+    Stage6TranscriptSqueezePlan { symbol: "stage6.inc_claim_reduction.gamma", label: "inc_reduction_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 },
 ];
 
 pub const STAGE6_TRANSCRIPT_ABSORB_BYTES: &[Stage6TranscriptAbsorbBytesPlan] = &[
@@ -185,407 +153,426 @@ pub const STAGE6_TRANSCRIPT_ABSORB_BYTES: &[Stage6TranscriptAbsorbBytesPlan] = &
 ];
 
 pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.UnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.Imm", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAddOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAddOperands", oracle: "OpFlagAddOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagSubtractOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagSubtractOperands", oracle: "OpFlagSubtractOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagMultiplyOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagMultiplyOperands", oracle: "OpFlagMultiplyOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagLoad", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagLoad", oracle: "OpFlagLoad", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagStore", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagStore", oracle: "OpFlagStore", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagJump", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagWriteLookupOutputToRD", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagVirtualInstruction", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAssert", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAssert", oracle: "OpFlagAssert", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", oracle: "OpFlagDoNotUpdateUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAdvice", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAdvice", oracle: "OpFlagAdvice", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsCompressed", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsCompressed", oracle: "OpFlagIsCompressed", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsFirstInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsLastInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsLastInSequence", oracle: "OpFlagIsLastInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagJump", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.InstructionFlagBranch", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.InstructionFlagBranch", oracle: "InstructionFlagBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagWriteLookupOutputToRD", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagVirtualInstruction", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.Imm", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.UnexpandedPC", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", oracle: "InstructionFlagLeftOperandIsRs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", oracle: "InstructionFlagLeftOperandIsPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", oracle: "InstructionFlagRightOperandIsRs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", oracle: "InstructionFlagRightOperandIsImm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.InstructionFlagIsNoop", oracle: "InstructionFlagIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.RdWa", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.Rs1Ra", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.Rs1Ra", oracle: "Rs1Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.Rs2Ra", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.Rs2Ra", oracle: "Rs2Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.registers_val_evaluation.RdWa", source_stage: "stage5", source_claim: "stage5.registers_val_evaluation.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.InstructionRafFlag", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRafFlag", oracle: "InstructionRafFlag", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_0", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_1", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_1", oracle: "LookupTableFlag_1", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_2", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_2", oracle: "LookupTableFlag_2", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_3", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_3", oracle: "LookupTableFlag_3", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_4", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_4", oracle: "LookupTableFlag_4", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_5", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_5", oracle: "LookupTableFlag_5", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_6", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_6", oracle: "LookupTableFlag_6", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_7", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_7", oracle: "LookupTableFlag_7", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_8", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_8", oracle: "LookupTableFlag_8", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_9", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_9", oracle: "LookupTableFlag_9", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_10", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_10", oracle: "LookupTableFlag_10", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_11", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_11", oracle: "LookupTableFlag_11", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_12", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_12", oracle: "LookupTableFlag_12", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_13", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_13", oracle: "LookupTableFlag_13", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_14", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_14", oracle: "LookupTableFlag_14", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_15", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_15", oracle: "LookupTableFlag_15", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_16", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_16", oracle: "LookupTableFlag_16", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_17", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_17", oracle: "LookupTableFlag_17", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_18", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_18", oracle: "LookupTableFlag_18", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_19", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_19", oracle: "LookupTableFlag_19", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_20", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_20", oracle: "LookupTableFlag_20", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_21", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_21", oracle: "LookupTableFlag_21", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_22", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_22", oracle: "LookupTableFlag_22", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_23", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_23", oracle: "LookupTableFlag_23", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_24", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_24", oracle: "LookupTableFlag_24", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_25", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_25", oracle: "LookupTableFlag_25", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_26", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_26", oracle: "LookupTableFlag_26", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_27", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_27", oracle: "LookupTableFlag_27", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_28", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_28", oracle: "LookupTableFlag_28", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_29", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_29", oracle: "LookupTableFlag_29", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_30", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_30", oracle: "LookupTableFlag_30", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_31", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_31", oracle: "LookupTableFlag_31", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_32", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_32", oracle: "LookupTableFlag_32", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_33", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_33", oracle: "LookupTableFlag_33", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_34", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_34", oracle: "LookupTableFlag_34", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_35", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_35", oracle: "LookupTableFlag_35", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_36", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_36", oracle: "LookupTableFlag_36", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_37", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_37", oracle: "LookupTableFlag_37", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_38", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_38", oracle: "LookupTableFlag_38", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_39", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_39", oracle: "LookupTableFlag_39", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_40", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_40", oracle: "LookupTableFlag_40", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.PC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.PC", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", source_stage: "stage5", source_claim: "stage5.ram_ra_claim_reduction.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.LookupOutput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.ram_read_write.RamInc", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.ram_val_check.RamInc", source_stage: "stage4", source_claim: "stage4.ram_val_check.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.registers_read_write.RdInc", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed" },
-    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.registers_val_evaluation.RdInc", source_stage: "stage5", source_claim: "stage5.registers_val_evaluation.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed" },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.UnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.Imm", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAddOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAddOperands", oracle: "OpFlagAddOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagSubtractOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagSubtractOperands", oracle: "OpFlagSubtractOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagMultiplyOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagMultiplyOperands", oracle: "OpFlagMultiplyOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagLoad", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagLoad", oracle: "OpFlagLoad", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagStore", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagStore", oracle: "OpFlagStore", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagJump", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagWriteLookupOutputToRD", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagVirtualInstruction", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAssert", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAssert", oracle: "OpFlagAssert", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", oracle: "OpFlagDoNotUpdateUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAdvice", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAdvice", oracle: "OpFlagAdvice", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsCompressed", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsCompressed", oracle: "OpFlagIsCompressed", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsFirstInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsLastInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsLastInSequence", oracle: "OpFlagIsLastInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagJump", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.InstructionFlagBranch", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.InstructionFlagBranch", oracle: "InstructionFlagBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagWriteLookupOutputToRD", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagVirtualInstruction", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.Imm", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.UnexpandedPC", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", oracle: "InstructionFlagLeftOperandIsRs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", oracle: "InstructionFlagLeftOperandIsPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", oracle: "InstructionFlagRightOperandIsRs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", oracle: "InstructionFlagRightOperandIsImm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.InstructionFlagIsNoop", oracle: "InstructionFlagIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.RdWa", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.Rs1Ra", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.Rs1Ra", oracle: "Rs1Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.Rs2Ra", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.Rs2Ra", oracle: "Rs2Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.registers_val_evaluation.RdWa", source_stage: "stage5", source_claim: "stage5.registers_val_evaluation.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.InstructionRafFlag", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRafFlag", oracle: "InstructionRafFlag", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_0", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_1", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_1", oracle: "LookupTableFlag_1", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_2", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_2", oracle: "LookupTableFlag_2", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_3", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_3", oracle: "LookupTableFlag_3", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_4", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_4", oracle: "LookupTableFlag_4", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_5", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_5", oracle: "LookupTableFlag_5", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_6", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_6", oracle: "LookupTableFlag_6", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_7", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_7", oracle: "LookupTableFlag_7", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_8", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_8", oracle: "LookupTableFlag_8", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_9", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_9", oracle: "LookupTableFlag_9", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_10", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_10", oracle: "LookupTableFlag_10", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_11", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_11", oracle: "LookupTableFlag_11", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_12", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_12", oracle: "LookupTableFlag_12", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_13", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_13", oracle: "LookupTableFlag_13", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_14", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_14", oracle: "LookupTableFlag_14", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_15", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_15", oracle: "LookupTableFlag_15", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_16", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_16", oracle: "LookupTableFlag_16", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_17", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_17", oracle: "LookupTableFlag_17", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_18", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_18", oracle: "LookupTableFlag_18", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_19", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_19", oracle: "LookupTableFlag_19", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_20", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_20", oracle: "LookupTableFlag_20", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_21", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_21", oracle: "LookupTableFlag_21", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_22", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_22", oracle: "LookupTableFlag_22", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_23", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_23", oracle: "LookupTableFlag_23", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_24", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_24", oracle: "LookupTableFlag_24", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_25", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_25", oracle: "LookupTableFlag_25", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_26", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_26", oracle: "LookupTableFlag_26", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_27", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_27", oracle: "LookupTableFlag_27", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_28", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_28", oracle: "LookupTableFlag_28", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_29", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_29", oracle: "LookupTableFlag_29", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_30", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_30", oracle: "LookupTableFlag_30", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_31", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_31", oracle: "LookupTableFlag_31", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_32", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_32", oracle: "LookupTableFlag_32", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_33", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_33", oracle: "LookupTableFlag_33", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_34", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_34", oracle: "LookupTableFlag_34", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_35", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_35", oracle: "LookupTableFlag_35", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_36", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_36", oracle: "LookupTableFlag_36", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_37", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_37", oracle: "LookupTableFlag_37", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_38", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_38", oracle: "LookupTableFlag_38", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_39", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_39", oracle: "LookupTableFlag_39", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_40", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_40", oracle: "LookupTableFlag_40", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.PC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.PC", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", source_stage: "stage5", source_claim: "stage5.ram_ra_claim_reduction.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage1.LookupOutput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage2.ram_read_write.RamInc", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.ram_val_check.RamInc", source_stage: "stage4", source_claim: "stage4.ram_val_check.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage4.registers_read_write.RdInc", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed },
+    Stage6OpeningInputPlan { symbol: "stage6.input.stage5.registers_val_evaluation.RdInc", source_stage: "stage5", source_claim: "stage5.registers_val_evaluation.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed },
 ];
 
 pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[
     Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 },
 ];
 
-macro_rules! stage6_field_expr {
-    ($symbol:literal, $formula:literal, $operands:literal) => {
-        Stage6FieldExprPlan { symbol: $symbol, kind: "op", formula: $formula, operands: $operands }
-    };
+const fn stage6_field_expr(symbol: &'static str, kind: Stage6FieldExprKind, operands: &'static [&'static str]) -> Stage6FieldExprPlan {
+    Stage6FieldExprPlan { symbol, kind, operands }
 }
 
 #[rustfmt::skip]
 pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[
-    stage6_field_expr!("stage6.booleanity.gamma_sq_0", "field.pow:0", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_1", "field.pow:2", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_2", "field.pow:4", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_3", "field.pow:6", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_4", "field.pow:8", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_5", "field.pow:10", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_6", "field.pow:12", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_7", "field.pow:14", "stage6.booleanity.gamma"),
-    stage6_field_expr!("stage6.booleanity.gamma_sq_8", "field.pow:16", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_9", "field.pow:18", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_10", "field.pow:20", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_11", "field.pow:22", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_12", "field.pow:24", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_13", "field.pow:26", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_14", "field.pow:28", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_15", "field.pow:30", "stage6.booleanity.gamma"),
-    stage6_field_expr!("stage6.booleanity.gamma_sq_16", "field.pow:32", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_17", "field.pow:34", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_18", "field.pow:36", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_19", "field.pow:38", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_20", "field.pow:40", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_21", "field.pow:42", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_22", "field.pow:44", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_23", "field.pow:46", "stage6.booleanity.gamma"),
-    stage6_field_expr!("stage6.booleanity.gamma_sq_24", "field.pow:48", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_25", "field.pow:50", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_26", "field.pow:52", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_27", "field.pow:54", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_28", "field.pow:56", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_29", "field.pow:58", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_30", "field.pow:60", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_31", "field.pow:62", "stage6.booleanity.gamma"),
-    stage6_field_expr!("stage6.booleanity.gamma_sq_32", "field.pow:64", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_33", "field.pow:66", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_34", "field.pow:68", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_35", "field.pow:70", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_36", "field.pow:72", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_37", "field.pow:74", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_38", "field.pow:76", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_0", "field.pow:0", "stage6.booleanity.gamma"),
-    stage6_field_expr!("stage6.booleanity.gamma_pow_1", "field.pow:1", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_2", "field.pow:2", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_3", "field.pow:3", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_4", "field.pow:4", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_5", "field.pow:5", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_6", "field.pow:6", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_7", "field.pow:7", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_8", "field.pow:8", "stage6.booleanity.gamma"),
-    stage6_field_expr!("stage6.booleanity.gamma_pow_9", "field.pow:9", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_10", "field.pow:10", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_11", "field.pow:11", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_12", "field.pow:12", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_13", "field.pow:13", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_14", "field.pow:14", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_15", "field.pow:15", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_16", "field.pow:16", "stage6.booleanity.gamma"),
-    stage6_field_expr!("stage6.booleanity.gamma_pow_17", "field.pow:17", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_18", "field.pow:18", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_19", "field.pow:19", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_20", "field.pow:20", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_21", "field.pow:21", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_22", "field.pow:22", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_23", "field.pow:23", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_24", "field.pow:24", "stage6.booleanity.gamma"),
-    stage6_field_expr!("stage6.booleanity.gamma_pow_25", "field.pow:25", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_26", "field.pow:26", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_27", "field.pow:27", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_28", "field.pow:28", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_29", "field.pow:29", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_30", "field.pow:30", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_31", "field.pow:31", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_32", "field.pow:32", "stage6.booleanity.gamma"),
-    stage6_field_expr!("stage6.booleanity.gamma_pow_33", "field.pow:33", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_34", "field.pow:34", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_35", "field.pow:35", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_36", "field.pow:36", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_37", "field.pow:37", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_38", "field.pow:38", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow|stage6.input.stage1.Imm"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow|stage6.input.stage1.OpFlagAddOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow|stage6.input.stage1.OpFlagSubtractOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow|stage6.input.stage1.OpFlagMultiplyOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", "field.pow:5", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow|stage6.input.stage1.OpFlagLoad"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", "field.pow:6", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow|stage6.input.stage1.OpFlagStore"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", "field.pow:7", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow|stage6.input.stage1.OpFlagJump"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", "field.pow:8", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow|stage6.input.stage1.OpFlagWriteLookupOutputToRD"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", "field.pow:9", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow|stage6.input.stage1.OpFlagVirtualInstruction"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", "field.pow:10", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow|stage6.input.stage1.OpFlagAssert"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", "field.pow:11", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow|stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", "field.pow:12", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow|stage6.input.stage1.OpFlagAdvice"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", "field.pow:13", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow|stage6.input.stage1.OpFlagIsCompressed"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", "field.pow:14", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow|stage6.input.stage1.OpFlagIsFirstInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", "field.pow:15", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow|stage6.input.stage1.OpFlagIsLastInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term16.gamma_pow|stage6.input.stage2.OpFlagJump"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow|stage6.input.stage2.InstructionFlagBranch"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term17.gamma_pow|stage6.bytecode_read_raf.claim.term17.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow|stage6.input.stage2.OpFlagWriteLookupOutputToRD"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term18.gamma_pow|stage6.bytecode_read_raf.claim.term18.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow|stage6.input.stage2.OpFlagVirtualInstruction"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term19.gamma_pow|stage6.bytecode_read_raf.claim.term19.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term20.gamma_pow|stage6.input.stage3.instruction_input.Imm"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow|stage6.input.stage3.spartan_shift.UnexpandedPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term21.gamma_pow|stage6.bytecode_read_raf.claim.term21.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term22.gamma_pow|stage6.bytecode_read_raf.claim.term22.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term23.gamma_pow|stage6.bytecode_read_raf.claim.term23.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term24.gamma_pow|stage6.bytecode_read_raf.claim.term24.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", "field.pow:5", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term25.gamma_pow|stage6.bytecode_read_raf.claim.term25.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", "field.pow:6", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow|stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term26.gamma_pow|stage6.bytecode_read_raf.claim.term26.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", "field.pow:7", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow|stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term27.gamma_pow|stage6.bytecode_read_raf.claim.term27.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", "field.pow:8", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow|stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term28.gamma_pow|stage6.bytecode_read_raf.claim.term28.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term29.gamma_pow|stage6.input.stage4.RdWa"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage4_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow|stage6.input.stage4.Rs1Ra"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term30.gamma_pow|stage6.bytecode_read_raf.claim.term30.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage4_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow|stage6.input.stage4.Rs2Ra"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term31.gamma_pow|stage6.bytecode_read_raf.claim.term31.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term32.gamma_pow|stage6.input.stage5.registers_val_evaluation.RdWa"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow|stage6.input.stage5.InstructionRafFlag"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term33.gamma_pow|stage6.bytecode_read_raf.claim.term33.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_0"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term34.gamma_pow|stage6.bytecode_read_raf.claim.term34.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_1"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term35.gamma_pow|stage6.bytecode_read_raf.claim.term35.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_2"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term36.gamma_pow|stage6.bytecode_read_raf.claim.term36.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", "field.pow:5", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_3"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term37.gamma_pow|stage6.bytecode_read_raf.claim.term37.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", "field.pow:6", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_4"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term38.gamma_pow|stage6.bytecode_read_raf.claim.term38.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", "field.pow:7", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_5"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term39.gamma_pow|stage6.bytecode_read_raf.claim.term39.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", "field.pow:8", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_6"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term40.gamma_pow|stage6.bytecode_read_raf.claim.term40.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", "field.pow:9", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_7"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term41.gamma_pow|stage6.bytecode_read_raf.claim.term41.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", "field.pow:10", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_8"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term42.gamma_pow|stage6.bytecode_read_raf.claim.term42.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", "field.pow:11", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_9"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term43.gamma_pow|stage6.bytecode_read_raf.claim.term43.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", "field.pow:12", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_10"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term44.gamma_pow|stage6.bytecode_read_raf.claim.term44.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", "field.pow:13", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_11"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term45.gamma_pow|stage6.bytecode_read_raf.claim.term45.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", "field.pow:14", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_12"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term46.gamma_pow|stage6.bytecode_read_raf.claim.term46.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", "field.pow:15", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_13"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term47.gamma_pow|stage6.bytecode_read_raf.claim.term47.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", "field.pow:16", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_14"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term48.gamma_pow|stage6.bytecode_read_raf.claim.term48.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", "field.pow:17", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_15"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term49.gamma_pow|stage6.bytecode_read_raf.claim.term49.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", "field.pow:18", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_16"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term50.gamma_pow|stage6.bytecode_read_raf.claim.term50.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", "field.pow:19", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_17"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term51.gamma_pow|stage6.bytecode_read_raf.claim.term51.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", "field.pow:20", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_18"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term52.gamma_pow|stage6.bytecode_read_raf.claim.term52.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", "field.pow:21", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_19"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term53.gamma_pow|stage6.bytecode_read_raf.claim.term53.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", "field.pow:22", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_20"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term54.gamma_pow|stage6.bytecode_read_raf.claim.term54.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", "field.pow:23", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_21"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term55.gamma_pow|stage6.bytecode_read_raf.claim.term55.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", "field.pow:24", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_22"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term56.gamma_pow|stage6.bytecode_read_raf.claim.term56.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", "field.pow:25", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_23"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term57.gamma_pow|stage6.bytecode_read_raf.claim.term57.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", "field.pow:26", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_24"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term58.gamma_pow|stage6.bytecode_read_raf.claim.term58.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", "field.pow:27", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_25"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term59.gamma_pow|stage6.bytecode_read_raf.claim.term59.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", "field.pow:28", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_26"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term60.gamma_pow|stage6.bytecode_read_raf.claim.term60.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", "field.pow:29", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_27"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term61.gamma_pow|stage6.bytecode_read_raf.claim.term61.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", "field.pow:30", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_28"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term62.gamma_pow|stage6.bytecode_read_raf.claim.term62.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", "field.pow:31", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_29"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term63.gamma_pow|stage6.bytecode_read_raf.claim.term63.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", "field.pow:32", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_30"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term64.gamma_pow|stage6.bytecode_read_raf.claim.term64.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", "field.pow:33", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_31"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term65.gamma_pow|stage6.bytecode_read_raf.claim.term65.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", "field.pow:34", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_32"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term66.gamma_pow|stage6.bytecode_read_raf.claim.term66.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", "field.pow:35", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_33"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term67.gamma_pow|stage6.bytecode_read_raf.claim.term67.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", "field.pow:36", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_34"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term68.gamma_pow|stage6.bytecode_read_raf.claim.term68.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", "field.pow:37", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_35"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term69.gamma_pow|stage6.bytecode_read_raf.claim.term69.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", "field.pow:38", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_36"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term70.gamma_pow|stage6.bytecode_read_raf.claim.term70.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", "field.pow:39", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_37"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term71.gamma_pow|stage6.bytecode_read_raf.claim.term71.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", "field.pow:40", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_38"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term72.gamma_pow|stage6.bytecode_read_raf.claim.term72.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", "field.pow:41", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_39"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term73.gamma_pow|stage6.bytecode_read_raf.claim.term73.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", "field.pow:42", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_40"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term74.gamma_pow|stage6.bytecode_read_raf.claim.term74.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_pow", "field.pow:5", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term75.gamma_pow|stage6.input.stage1.PC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_pow", "field.pow:6", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term76.gamma_pow|stage6.input.stage3.spartan_shift.PC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.entry_constant", "field.pow:7", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial0", "field.add", "stage6.input.stage1.UnexpandedPC|stage6.bytecode_read_raf.claim.term1.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial1", "field.add", "stage6.bytecode_read_raf.claim_expr.partial0|stage6.bytecode_read_raf.claim.term2.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial2", "field.add", "stage6.bytecode_read_raf.claim_expr.partial1|stage6.bytecode_read_raf.claim.term3.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial3", "field.add", "stage6.bytecode_read_raf.claim_expr.partial2|stage6.bytecode_read_raf.claim.term4.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial4", "field.add", "stage6.bytecode_read_raf.claim_expr.partial3|stage6.bytecode_read_raf.claim.term5.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial5", "field.add", "stage6.bytecode_read_raf.claim_expr.partial4|stage6.bytecode_read_raf.claim.term6.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial6", "field.add", "stage6.bytecode_read_raf.claim_expr.partial5|stage6.bytecode_read_raf.claim.term7.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial7", "field.add", "stage6.bytecode_read_raf.claim_expr.partial6|stage6.bytecode_read_raf.claim.term8.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial8", "field.add", "stage6.bytecode_read_raf.claim_expr.partial7|stage6.bytecode_read_raf.claim.term9.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial9", "field.add", "stage6.bytecode_read_raf.claim_expr.partial8|stage6.bytecode_read_raf.claim.term10.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial10", "field.add", "stage6.bytecode_read_raf.claim_expr.partial9|stage6.bytecode_read_raf.claim.term11.stage_gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial11", "field.add", "stage6.bytecode_read_raf.claim_expr.partial10|stage6.bytecode_read_raf.claim.term12.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial12", "field.add", "stage6.bytecode_read_raf.claim_expr.partial11|stage6.bytecode_read_raf.claim.term13.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial13", "field.add", "stage6.bytecode_read_raf.claim_expr.partial12|stage6.bytecode_read_raf.claim.term14.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial14", "field.add", "stage6.bytecode_read_raf.claim_expr.partial13|stage6.bytecode_read_raf.claim.term15.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial15", "field.add", "stage6.bytecode_read_raf.claim_expr.partial14|stage6.bytecode_read_raf.claim.term16.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial16", "field.add", "stage6.bytecode_read_raf.claim_expr.partial15|stage6.bytecode_read_raf.claim.term17.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial17", "field.add", "stage6.bytecode_read_raf.claim_expr.partial16|stage6.bytecode_read_raf.claim.term18.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial18", "field.add", "stage6.bytecode_read_raf.claim_expr.partial17|stage6.bytecode_read_raf.claim.term19.gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial19", "field.add", "stage6.bytecode_read_raf.claim_expr.partial18|stage6.bytecode_read_raf.claim.term20.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial20", "field.add", "stage6.bytecode_read_raf.claim_expr.partial19|stage6.bytecode_read_raf.claim.term21.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial21", "field.add", "stage6.bytecode_read_raf.claim_expr.partial20|stage6.bytecode_read_raf.claim.term22.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial22", "field.add", "stage6.bytecode_read_raf.claim_expr.partial21|stage6.bytecode_read_raf.claim.term23.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial23", "field.add", "stage6.bytecode_read_raf.claim_expr.partial22|stage6.bytecode_read_raf.claim.term24.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial24", "field.add", "stage6.bytecode_read_raf.claim_expr.partial23|stage6.bytecode_read_raf.claim.term25.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial25", "field.add", "stage6.bytecode_read_raf.claim_expr.partial24|stage6.bytecode_read_raf.claim.term26.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial26", "field.add", "stage6.bytecode_read_raf.claim_expr.partial25|stage6.bytecode_read_raf.claim.term27.gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial27", "field.add", "stage6.bytecode_read_raf.claim_expr.partial26|stage6.bytecode_read_raf.claim.term28.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial28", "field.add", "stage6.bytecode_read_raf.claim_expr.partial27|stage6.bytecode_read_raf.claim.term29.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial29", "field.add", "stage6.bytecode_read_raf.claim_expr.partial28|stage6.bytecode_read_raf.claim.term30.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial30", "field.add", "stage6.bytecode_read_raf.claim_expr.partial29|stage6.bytecode_read_raf.claim.term31.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial31", "field.add", "stage6.bytecode_read_raf.claim_expr.partial30|stage6.bytecode_read_raf.claim.term32.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial32", "field.add", "stage6.bytecode_read_raf.claim_expr.partial31|stage6.bytecode_read_raf.claim.term33.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial33", "field.add", "stage6.bytecode_read_raf.claim_expr.partial32|stage6.bytecode_read_raf.claim.term34.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial34", "field.add", "stage6.bytecode_read_raf.claim_expr.partial33|stage6.bytecode_read_raf.claim.term35.gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial35", "field.add", "stage6.bytecode_read_raf.claim_expr.partial34|stage6.bytecode_read_raf.claim.term36.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial36", "field.add", "stage6.bytecode_read_raf.claim_expr.partial35|stage6.bytecode_read_raf.claim.term37.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial37", "field.add", "stage6.bytecode_read_raf.claim_expr.partial36|stage6.bytecode_read_raf.claim.term38.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial38", "field.add", "stage6.bytecode_read_raf.claim_expr.partial37|stage6.bytecode_read_raf.claim.term39.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial39", "field.add", "stage6.bytecode_read_raf.claim_expr.partial38|stage6.bytecode_read_raf.claim.term40.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial40", "field.add", "stage6.bytecode_read_raf.claim_expr.partial39|stage6.bytecode_read_raf.claim.term41.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial41", "field.add", "stage6.bytecode_read_raf.claim_expr.partial40|stage6.bytecode_read_raf.claim.term42.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial42", "field.add", "stage6.bytecode_read_raf.claim_expr.partial41|stage6.bytecode_read_raf.claim.term43.gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial43", "field.add", "stage6.bytecode_read_raf.claim_expr.partial42|stage6.bytecode_read_raf.claim.term44.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial44", "field.add", "stage6.bytecode_read_raf.claim_expr.partial43|stage6.bytecode_read_raf.claim.term45.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial45", "field.add", "stage6.bytecode_read_raf.claim_expr.partial44|stage6.bytecode_read_raf.claim.term46.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial46", "field.add", "stage6.bytecode_read_raf.claim_expr.partial45|stage6.bytecode_read_raf.claim.term47.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial47", "field.add", "stage6.bytecode_read_raf.claim_expr.partial46|stage6.bytecode_read_raf.claim.term48.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial48", "field.add", "stage6.bytecode_read_raf.claim_expr.partial47|stage6.bytecode_read_raf.claim.term49.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial49", "field.add", "stage6.bytecode_read_raf.claim_expr.partial48|stage6.bytecode_read_raf.claim.term50.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial50", "field.add", "stage6.bytecode_read_raf.claim_expr.partial49|stage6.bytecode_read_raf.claim.term51.gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial51", "field.add", "stage6.bytecode_read_raf.claim_expr.partial50|stage6.bytecode_read_raf.claim.term52.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial52", "field.add", "stage6.bytecode_read_raf.claim_expr.partial51|stage6.bytecode_read_raf.claim.term53.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial53", "field.add", "stage6.bytecode_read_raf.claim_expr.partial52|stage6.bytecode_read_raf.claim.term54.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial54", "field.add", "stage6.bytecode_read_raf.claim_expr.partial53|stage6.bytecode_read_raf.claim.term55.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial55", "field.add", "stage6.bytecode_read_raf.claim_expr.partial54|stage6.bytecode_read_raf.claim.term56.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial56", "field.add", "stage6.bytecode_read_raf.claim_expr.partial55|stage6.bytecode_read_raf.claim.term57.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial57", "field.add", "stage6.bytecode_read_raf.claim_expr.partial56|stage6.bytecode_read_raf.claim.term58.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial58", "field.add", "stage6.bytecode_read_raf.claim_expr.partial57|stage6.bytecode_read_raf.claim.term59.gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial59", "field.add", "stage6.bytecode_read_raf.claim_expr.partial58|stage6.bytecode_read_raf.claim.term60.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial60", "field.add", "stage6.bytecode_read_raf.claim_expr.partial59|stage6.bytecode_read_raf.claim.term61.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial61", "field.add", "stage6.bytecode_read_raf.claim_expr.partial60|stage6.bytecode_read_raf.claim.term62.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial62", "field.add", "stage6.bytecode_read_raf.claim_expr.partial61|stage6.bytecode_read_raf.claim.term63.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial63", "field.add", "stage6.bytecode_read_raf.claim_expr.partial62|stage6.bytecode_read_raf.claim.term64.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial64", "field.add", "stage6.bytecode_read_raf.claim_expr.partial63|stage6.bytecode_read_raf.claim.term65.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial65", "field.add", "stage6.bytecode_read_raf.claim_expr.partial64|stage6.bytecode_read_raf.claim.term66.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial66", "field.add", "stage6.bytecode_read_raf.claim_expr.partial65|stage6.bytecode_read_raf.claim.term67.gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial67", "field.add", "stage6.bytecode_read_raf.claim_expr.partial66|stage6.bytecode_read_raf.claim.term68.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial68", "field.add", "stage6.bytecode_read_raf.claim_expr.partial67|stage6.bytecode_read_raf.claim.term69.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial69", "field.add", "stage6.bytecode_read_raf.claim_expr.partial68|stage6.bytecode_read_raf.claim.term70.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial70", "field.add", "stage6.bytecode_read_raf.claim_expr.partial69|stage6.bytecode_read_raf.claim.term71.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial71", "field.add", "stage6.bytecode_read_raf.claim_expr.partial70|stage6.bytecode_read_raf.claim.term72.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial72", "field.add", "stage6.bytecode_read_raf.claim_expr.partial71|stage6.bytecode_read_raf.claim.term73.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial73", "field.add", "stage6.bytecode_read_raf.claim_expr.partial72|stage6.bytecode_read_raf.claim.term74.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial74", "field.add", "stage6.bytecode_read_raf.claim_expr.partial73|stage6.bytecode_read_raf.claim.term75.gamma_term"),
-    stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial75", "field.add", "stage6.bytecode_read_raf.claim_expr.partial74|stage6.bytecode_read_raf.claim.term76.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial76", "field.add", "stage6.bytecode_read_raf.claim_expr.partial75|stage6.bytecode_read_raf.claim.entry_constant"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_pow", "field.pow:1", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term1.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_1"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_pow", "field.pow:2", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term2.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_2"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_pow", "field.pow:3", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term3.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_3"),
-    stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_pow", "field.pow:4", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term4.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_4"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_pow", "field.pow:5", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term5.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_5"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_pow", "field.pow:6", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term6.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_6"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_pow", "field.pow:7", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term7.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_7"),
-    stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial0", "field.add", "stage6.input.stage5.instruction_read_raf.InstructionRa_0|stage6.instruction_ra_virtual.claim.term1.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial1", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial0|stage6.instruction_ra_virtual.claim.term2.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial2", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial1|stage6.instruction_ra_virtual.claim.term3.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial3", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial2|stage6.instruction_ra_virtual.claim.term4.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial4", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial3|stage6.instruction_ra_virtual.claim.term5.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial5", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial4|stage6.instruction_ra_virtual.claim.term6.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial6", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial5|stage6.instruction_ra_virtual.claim.term7.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "field.pow:1", "stage6.inc_claim_reduction.gamma"),
-    stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", "field.mul", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow|stage6.input.stage4.ram_val_check.RamInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "field.pow:2", "stage6.inc_claim_reduction.gamma"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", "field.mul", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow|stage6.input.stage4.registers_read_write.RdInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "field.pow:3", "stage6.inc_claim_reduction.gamma"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", "field.mul", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow|stage6.input.stage5.registers_val_evaluation.RdInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial0", "field.add", "stage6.input.stage2.ram_read_write.RamInc|stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial1", "field.add", "stage6.inc_claim_reduction.claim_expr.partial0|stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial2", "field.add", "stage6.inc_claim_reduction.claim_expr.partial1|stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", "stage6.input.stage1.Imm"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", "stage6.input.stage1.OpFlagAddOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", "stage6.input.stage1.OpFlagSubtractOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", "stage6.input.stage1.OpFlagMultiplyOperands"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", "stage6.input.stage1.OpFlagLoad"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", "stage6.input.stage1.OpFlagStore"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", "stage6.input.stage1.OpFlagJump"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", "stage6.input.stage1.OpFlagWriteLookupOutputToRD"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", "stage6.input.stage1.OpFlagVirtualInstruction"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", "stage6.input.stage1.OpFlagAssert"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", "stage6.input.stage1.OpFlagAdvice"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", "stage6.input.stage1.OpFlagIsCompressed"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", "stage6.input.stage1.OpFlagIsFirstInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", "stage6.input.stage1.OpFlagIsLastInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term16.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term16.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term16.gamma_pow", "stage6.input.stage2.OpFlagJump"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", "stage6.input.stage2.InstructionFlagBranch"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.gamma_pow", "stage6.bytecode_read_raf.claim.term17.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", "stage6.input.stage2.OpFlagWriteLookupOutputToRD"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.gamma_pow", "stage6.bytecode_read_raf.claim.term18.stage_gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", "stage6.input.stage2.OpFlagVirtualInstruction"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.gamma_pow", "stage6.bytecode_read_raf.claim.term19.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term20.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term20.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term20.gamma_pow", "stage6.input.stage3.instruction_input.Imm"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", "stage6.input.stage3.spartan_shift.UnexpandedPC"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term21.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.gamma_pow", "stage6.bytecode_read_raf.claim.term21.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.gamma_pow", "stage6.bytecode_read_raf.claim.term22.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term23.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.gamma_pow", "stage6.bytecode_read_raf.claim.term23.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.gamma_pow", "stage6.bytecode_read_raf.claim.term24.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term25.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.gamma_pow", "stage6.bytecode_read_raf.claim.term25.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.gamma_pow", "stage6.bytecode_read_raf.claim.term26.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term27.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.gamma_pow", "stage6.bytecode_read_raf.claim.term27.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.gamma_pow", "stage6.bytecode_read_raf.claim.term28.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term29.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term29.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term29.gamma_pow", "stage6.input.stage4.RdWa"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", "stage6.input.stage4.Rs1Ra"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.gamma_pow", "stage6.bytecode_read_raf.claim.term30.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", "stage6.input.stage4.Rs2Ra"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.gamma_pow", "stage6.bytecode_read_raf.claim.term31.stage_gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term32.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term32.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term32.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdWa"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", "stage6.input.stage5.InstructionRafFlag"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.gamma_pow", "stage6.bytecode_read_raf.claim.term33.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_0"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term34.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.gamma_pow", "stage6.bytecode_read_raf.claim.term34.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_1"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.gamma_pow", "stage6.bytecode_read_raf.claim.term35.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_2"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term36.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.gamma_pow", "stage6.bytecode_read_raf.claim.term36.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_3"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.gamma_pow", "stage6.bytecode_read_raf.claim.term37.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_4"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term38.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.gamma_pow", "stage6.bytecode_read_raf.claim.term38.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_5"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.gamma_pow", "stage6.bytecode_read_raf.claim.term39.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_6"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term40.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.gamma_pow", "stage6.bytecode_read_raf.claim.term40.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_7"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.gamma_pow", "stage6.bytecode_read_raf.claim.term41.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_8"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term42.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.gamma_pow", "stage6.bytecode_read_raf.claim.term42.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_9"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.gamma_pow", "stage6.bytecode_read_raf.claim.term43.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_10"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term44.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.gamma_pow", "stage6.bytecode_read_raf.claim.term44.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_11"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.gamma_pow", "stage6.bytecode_read_raf.claim.term45.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_12"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term46.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.gamma_pow", "stage6.bytecode_read_raf.claim.term46.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_13"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.gamma_pow", "stage6.bytecode_read_raf.claim.term47.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", Stage6FieldExprKind::Pow(16), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_14"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term48.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.gamma_pow", "stage6.bytecode_read_raf.claim.term48.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", Stage6FieldExprKind::Pow(17), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_15"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.gamma_pow", "stage6.bytecode_read_raf.claim.term49.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", Stage6FieldExprKind::Pow(18), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_16"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term50.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.gamma_pow", "stage6.bytecode_read_raf.claim.term50.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", Stage6FieldExprKind::Pow(19), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_17"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.gamma_pow", "stage6.bytecode_read_raf.claim.term51.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", Stage6FieldExprKind::Pow(20), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_18"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term52.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.gamma_pow", "stage6.bytecode_read_raf.claim.term52.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", Stage6FieldExprKind::Pow(21), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_19"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.gamma_pow", "stage6.bytecode_read_raf.claim.term53.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", Stage6FieldExprKind::Pow(22), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_20"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term54.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.gamma_pow", "stage6.bytecode_read_raf.claim.term54.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", Stage6FieldExprKind::Pow(23), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_21"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.gamma_pow", "stage6.bytecode_read_raf.claim.term55.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", Stage6FieldExprKind::Pow(24), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_22"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term56.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.gamma_pow", "stage6.bytecode_read_raf.claim.term56.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", Stage6FieldExprKind::Pow(25), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_23"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.gamma_pow", "stage6.bytecode_read_raf.claim.term57.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", Stage6FieldExprKind::Pow(26), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_24"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term58.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.gamma_pow", "stage6.bytecode_read_raf.claim.term58.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", Stage6FieldExprKind::Pow(27), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_25"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.gamma_pow", "stage6.bytecode_read_raf.claim.term59.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", Stage6FieldExprKind::Pow(28), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_26"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term60.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.gamma_pow", "stage6.bytecode_read_raf.claim.term60.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", Stage6FieldExprKind::Pow(29), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_27"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.gamma_pow", "stage6.bytecode_read_raf.claim.term61.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", Stage6FieldExprKind::Pow(30), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_28"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term62.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.gamma_pow", "stage6.bytecode_read_raf.claim.term62.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", Stage6FieldExprKind::Pow(31), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_29"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.gamma_pow", "stage6.bytecode_read_raf.claim.term63.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", Stage6FieldExprKind::Pow(32), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_30"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term64.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.gamma_pow", "stage6.bytecode_read_raf.claim.term64.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", Stage6FieldExprKind::Pow(33), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_31"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.gamma_pow", "stage6.bytecode_read_raf.claim.term65.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", Stage6FieldExprKind::Pow(34), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_32"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term66.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.gamma_pow", "stage6.bytecode_read_raf.claim.term66.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", Stage6FieldExprKind::Pow(35), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_33"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.gamma_pow", "stage6.bytecode_read_raf.claim.term67.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", Stage6FieldExprKind::Pow(36), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_34"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term68.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.gamma_pow", "stage6.bytecode_read_raf.claim.term68.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", Stage6FieldExprKind::Pow(37), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_35"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.gamma_pow", "stage6.bytecode_read_raf.claim.term69.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", Stage6FieldExprKind::Pow(38), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_36"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term70.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.gamma_pow", "stage6.bytecode_read_raf.claim.term70.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", Stage6FieldExprKind::Pow(39), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_37"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.gamma_pow", "stage6.bytecode_read_raf.claim.term71.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", Stage6FieldExprKind::Pow(40), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_38"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term72.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.gamma_pow", "stage6.bytecode_read_raf.claim.term72.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", Stage6FieldExprKind::Pow(41), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_39"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.gamma_pow", "stage6.bytecode_read_raf.claim.term73.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", Stage6FieldExprKind::Pow(42), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_40"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim.term74.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.gamma_pow", "stage6.bytecode_read_raf.claim.term74.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term75.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term75.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term75.gamma_pow", "stage6.input.stage1.PC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term76.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term76.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term76.gamma_pow", "stage6.input.stage3.spartan_shift.PC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.entry_constant", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage1.UnexpandedPC", "stage6.bytecode_read_raf.claim.term1.stage_gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial0", "stage6.bytecode_read_raf.claim.term2.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial1", "stage6.bytecode_read_raf.claim.term3.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial2", "stage6.bytecode_read_raf.claim.term4.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial3", "stage6.bytecode_read_raf.claim.term5.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial4", "stage6.bytecode_read_raf.claim.term6.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial5", "stage6.bytecode_read_raf.claim.term7.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial7", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial6", "stage6.bytecode_read_raf.claim.term8.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial8", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial7", "stage6.bytecode_read_raf.claim.term9.stage_gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial9", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial8", "stage6.bytecode_read_raf.claim.term10.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial10", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial9", "stage6.bytecode_read_raf.claim.term11.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial11", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial10", "stage6.bytecode_read_raf.claim.term12.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial12", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial11", "stage6.bytecode_read_raf.claim.term13.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial13", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial12", "stage6.bytecode_read_raf.claim.term14.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial14", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial13", "stage6.bytecode_read_raf.claim.term15.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial15", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial14", "stage6.bytecode_read_raf.claim.term16.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial16", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial15", "stage6.bytecode_read_raf.claim.term17.gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial17", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial16", "stage6.bytecode_read_raf.claim.term18.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial18", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial17", "stage6.bytecode_read_raf.claim.term19.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial19", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial18", "stage6.bytecode_read_raf.claim.term20.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial20", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial19", "stage6.bytecode_read_raf.claim.term21.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial21", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial20", "stage6.bytecode_read_raf.claim.term22.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial22", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial21", "stage6.bytecode_read_raf.claim.term23.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial23", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial22", "stage6.bytecode_read_raf.claim.term24.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial24", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial23", "stage6.bytecode_read_raf.claim.term25.gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial25", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial24", "stage6.bytecode_read_raf.claim.term26.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial26", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial25", "stage6.bytecode_read_raf.claim.term27.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial27", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial26", "stage6.bytecode_read_raf.claim.term28.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial28", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial27", "stage6.bytecode_read_raf.claim.term29.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial29", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial28", "stage6.bytecode_read_raf.claim.term30.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial30", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial29", "stage6.bytecode_read_raf.claim.term31.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial31", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial30", "stage6.bytecode_read_raf.claim.term32.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial32", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial31", "stage6.bytecode_read_raf.claim.term33.gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial33", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial32", "stage6.bytecode_read_raf.claim.term34.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial34", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial33", "stage6.bytecode_read_raf.claim.term35.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial35", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial34", "stage6.bytecode_read_raf.claim.term36.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial36", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial35", "stage6.bytecode_read_raf.claim.term37.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial37", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial36", "stage6.bytecode_read_raf.claim.term38.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial38", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial37", "stage6.bytecode_read_raf.claim.term39.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial39", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial38", "stage6.bytecode_read_raf.claim.term40.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial40", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial39", "stage6.bytecode_read_raf.claim.term41.gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial41", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial40", "stage6.bytecode_read_raf.claim.term42.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial42", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial41", "stage6.bytecode_read_raf.claim.term43.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial43", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial42", "stage6.bytecode_read_raf.claim.term44.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial44", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial43", "stage6.bytecode_read_raf.claim.term45.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial45", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial44", "stage6.bytecode_read_raf.claim.term46.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial46", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial45", "stage6.bytecode_read_raf.claim.term47.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial47", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial46", "stage6.bytecode_read_raf.claim.term48.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial48", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial47", "stage6.bytecode_read_raf.claim.term49.gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial49", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial48", "stage6.bytecode_read_raf.claim.term50.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial50", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial49", "stage6.bytecode_read_raf.claim.term51.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial51", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial50", "stage6.bytecode_read_raf.claim.term52.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial52", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial51", "stage6.bytecode_read_raf.claim.term53.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial53", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial52", "stage6.bytecode_read_raf.claim.term54.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial54", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial53", "stage6.bytecode_read_raf.claim.term55.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial55", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial54", "stage6.bytecode_read_raf.claim.term56.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial56", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial55", "stage6.bytecode_read_raf.claim.term57.gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial57", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial56", "stage6.bytecode_read_raf.claim.term58.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial58", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial57", "stage6.bytecode_read_raf.claim.term59.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial59", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial58", "stage6.bytecode_read_raf.claim.term60.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial60", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial59", "stage6.bytecode_read_raf.claim.term61.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial61", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial60", "stage6.bytecode_read_raf.claim.term62.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial62", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial61", "stage6.bytecode_read_raf.claim.term63.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial63", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial62", "stage6.bytecode_read_raf.claim.term64.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial64", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial63", "stage6.bytecode_read_raf.claim.term65.gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial65", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial64", "stage6.bytecode_read_raf.claim.term66.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial66", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial65", "stage6.bytecode_read_raf.claim.term67.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial67", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial66", "stage6.bytecode_read_raf.claim.term68.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial68", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial67", "stage6.bytecode_read_raf.claim.term69.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial69", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial68", "stage6.bytecode_read_raf.claim.term70.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial70", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial69", "stage6.bytecode_read_raf.claim.term71.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial71", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial70", "stage6.bytecode_read_raf.claim.term72.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial72", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial71", "stage6.bytecode_read_raf.claim.term73.gamma_term"]),
+    stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial73", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial72", "stage6.bytecode_read_raf.claim.term74.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial74", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial73", "stage6.bytecode_read_raf.claim.term75.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial75", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial74", "stage6.bytecode_read_raf.claim.term76.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial76", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial75", "stage6.bytecode_read_raf.claim.entry_constant"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term1.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term1.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term1.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_1"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term2.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term2.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term2.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_2"]),
+    stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]),
+    stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]),
+    stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]),
+    stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), stage6_field_expr("stage6.booleanity.output.term0.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_0", "stage6.booleanity.eval.InstructionRa_0"]), stage6_field_expr("stage6.booleanity.output.term0.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term0.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_0"]), stage6_field_expr("stage6.booleanity.output.term0", Stage6FieldExprKind::Product, &["stage6.booleanity.output.term0.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term1.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_1", "stage6.booleanity.eval.InstructionRa_1"]), stage6_field_expr("stage6.booleanity.output.term1.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term1.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_1"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term1", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_2", "stage6.booleanity.output.term1.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term2.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_2", "stage6.booleanity.eval.InstructionRa_2"]), stage6_field_expr("stage6.booleanity.output.term2.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term2.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_2"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term2", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_4", "stage6.booleanity.output.term2.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term3.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_3", "stage6.booleanity.eval.InstructionRa_3"]), stage6_field_expr("stage6.booleanity.output.term3.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term3.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_3"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term3", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_6", "stage6.booleanity.output.term3.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term4.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_4", "stage6.booleanity.eval.InstructionRa_4"]), stage6_field_expr("stage6.booleanity.output.term4.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term4.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_4"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_8", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term4", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_8", "stage6.booleanity.output.term4.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term5.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_5", "stage6.booleanity.eval.InstructionRa_5"]), stage6_field_expr("stage6.booleanity.output.term5.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term5.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_5"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_10", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term5", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_10", "stage6.booleanity.output.term5.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term6.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_6", "stage6.booleanity.eval.InstructionRa_6"]), stage6_field_expr("stage6.booleanity.output.term6.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term6.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_6"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_12", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term6", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_12", "stage6.booleanity.output.term6.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term7.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_7", "stage6.booleanity.eval.InstructionRa_7"]), stage6_field_expr("stage6.booleanity.output.term7.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term7.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_7"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_14", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term7", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_14", "stage6.booleanity.output.term7.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term8.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_8", "stage6.booleanity.eval.InstructionRa_8"]), stage6_field_expr("stage6.booleanity.output.term8.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term8.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_8"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_16", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term8", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_16", "stage6.booleanity.output.term8.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term9.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_9", "stage6.booleanity.eval.InstructionRa_9"]), stage6_field_expr("stage6.booleanity.output.term9.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term9.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_9"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_18", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term9", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_18", "stage6.booleanity.output.term9.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term10.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_10", "stage6.booleanity.eval.InstructionRa_10"]), stage6_field_expr("stage6.booleanity.output.term10.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term10.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_10"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_20", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term10", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_20", "stage6.booleanity.output.term10.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term11.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_11", "stage6.booleanity.eval.InstructionRa_11"]), stage6_field_expr("stage6.booleanity.output.term11.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term11.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_11"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_22", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term11", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_22", "stage6.booleanity.output.term11.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term12.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_12", "stage6.booleanity.eval.InstructionRa_12"]), stage6_field_expr("stage6.booleanity.output.term12.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term12.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_12"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_24", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term12", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_24", "stage6.booleanity.output.term12.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term13.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_13", "stage6.booleanity.eval.InstructionRa_13"]), stage6_field_expr("stage6.booleanity.output.term13.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term13.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_13"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_26", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term13", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_26", "stage6.booleanity.output.term13.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term14.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_14", "stage6.booleanity.eval.InstructionRa_14"]), stage6_field_expr("stage6.booleanity.output.term14.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term14.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_14"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_28", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term14", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_28", "stage6.booleanity.output.term14.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term15.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_15", "stage6.booleanity.eval.InstructionRa_15"]), stage6_field_expr("stage6.booleanity.output.term15.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term15.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_15"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_30", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term15", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_30", "stage6.booleanity.output.term15.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term16.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_16", "stage6.booleanity.eval.InstructionRa_16"]), stage6_field_expr("stage6.booleanity.output.term16.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term16.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_16"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_32", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term16", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_32", "stage6.booleanity.output.term16.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term17.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_17", "stage6.booleanity.eval.InstructionRa_17"]), stage6_field_expr("stage6.booleanity.output.term17.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term17.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_17"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_34", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term17", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_34", "stage6.booleanity.output.term17.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term18.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_18", "stage6.booleanity.eval.InstructionRa_18"]), stage6_field_expr("stage6.booleanity.output.term18.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term18.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_18"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_36", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term18", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_36", "stage6.booleanity.output.term18.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term19.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_19", "stage6.booleanity.eval.InstructionRa_19"]), stage6_field_expr("stage6.booleanity.output.term19.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term19.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_19"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_38", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term19", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_38", "stage6.booleanity.output.term19.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term20.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_20", "stage6.booleanity.eval.InstructionRa_20"]), stage6_field_expr("stage6.booleanity.output.term20.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term20.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_20"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_40", Stage6FieldExprKind::Pow(40), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term20", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_40", "stage6.booleanity.output.term20.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term21.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_21", "stage6.booleanity.eval.InstructionRa_21"]), stage6_field_expr("stage6.booleanity.output.term21.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term21.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_21"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_42", Stage6FieldExprKind::Pow(42), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term21", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_42", "stage6.booleanity.output.term21.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term22.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_22", "stage6.booleanity.eval.InstructionRa_22"]), stage6_field_expr("stage6.booleanity.output.term22.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term22.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_22"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_44", Stage6FieldExprKind::Pow(44), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term22", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_44", "stage6.booleanity.output.term22.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term23.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_23", "stage6.booleanity.eval.InstructionRa_23"]), stage6_field_expr("stage6.booleanity.output.term23.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term23.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_23"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_46", Stage6FieldExprKind::Pow(46), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term23", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_46", "stage6.booleanity.output.term23.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term24.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_24", "stage6.booleanity.eval.InstructionRa_24"]), stage6_field_expr("stage6.booleanity.output.term24.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term24.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_24"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_48", Stage6FieldExprKind::Pow(48), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term24", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_48", "stage6.booleanity.output.term24.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term25.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_25", "stage6.booleanity.eval.InstructionRa_25"]), stage6_field_expr("stage6.booleanity.output.term25.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term25.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_25"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_50", Stage6FieldExprKind::Pow(50), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term25", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_50", "stage6.booleanity.output.term25.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term26.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_26", "stage6.booleanity.eval.InstructionRa_26"]), stage6_field_expr("stage6.booleanity.output.term26.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term26.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_26"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_52", Stage6FieldExprKind::Pow(52), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term26", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_52", "stage6.booleanity.output.term26.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term27.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_27", "stage6.booleanity.eval.InstructionRa_27"]), stage6_field_expr("stage6.booleanity.output.term27.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term27.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_27"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_54", Stage6FieldExprKind::Pow(54), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term27", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_54", "stage6.booleanity.output.term27.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term28.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_28", "stage6.booleanity.eval.InstructionRa_28"]), stage6_field_expr("stage6.booleanity.output.term28.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term28.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_28"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_56", Stage6FieldExprKind::Pow(56), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term28", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_56", "stage6.booleanity.output.term28.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term29.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_29", "stage6.booleanity.eval.InstructionRa_29"]), stage6_field_expr("stage6.booleanity.output.term29.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term29.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_29"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_58", Stage6FieldExprKind::Pow(58), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term29", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_58", "stage6.booleanity.output.term29.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term30.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_30", "stage6.booleanity.eval.InstructionRa_30"]), stage6_field_expr("stage6.booleanity.output.term30.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term30.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_30"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_60", Stage6FieldExprKind::Pow(60), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term30", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_60", "stage6.booleanity.output.term30.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term31.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_31", "stage6.booleanity.eval.InstructionRa_31"]), stage6_field_expr("stage6.booleanity.output.term31.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term31.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_31"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_62", Stage6FieldExprKind::Pow(62), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term31", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_62", "stage6.booleanity.output.term31.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term32.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.BytecodeRa_0", "stage6.booleanity.eval.BytecodeRa_0"]), stage6_field_expr("stage6.booleanity.output.term32.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term32.boolean_zero.square", "stage6.booleanity.eval.BytecodeRa_0"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_64", Stage6FieldExprKind::Pow(64), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term32", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_64", "stage6.booleanity.output.term32.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term33.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.BytecodeRa_1", "stage6.booleanity.eval.BytecodeRa_1"]), stage6_field_expr("stage6.booleanity.output.term33.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term33.boolean_zero.square", "stage6.booleanity.eval.BytecodeRa_1"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_66", Stage6FieldExprKind::Pow(66), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term33", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_66", "stage6.booleanity.output.term33.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term34.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.BytecodeRa_2", "stage6.booleanity.eval.BytecodeRa_2"]), stage6_field_expr("stage6.booleanity.output.term34.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term34.boolean_zero.square", "stage6.booleanity.eval.BytecodeRa_2"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_68", Stage6FieldExprKind::Pow(68), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term34", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_68", "stage6.booleanity.output.term34.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term35.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.RamRa_0", "stage6.booleanity.eval.RamRa_0"]), stage6_field_expr("stage6.booleanity.output.term35.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term35.boolean_zero.square", "stage6.booleanity.eval.RamRa_0"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_70", Stage6FieldExprKind::Pow(70), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term35", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_70", "stage6.booleanity.output.term35.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term36.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.RamRa_1", "stage6.booleanity.eval.RamRa_1"]), stage6_field_expr("stage6.booleanity.output.term36.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term36.boolean_zero.square", "stage6.booleanity.eval.RamRa_1"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_72", Stage6FieldExprKind::Pow(72), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term36", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_72", "stage6.booleanity.output.term36.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term37.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.RamRa_2", "stage6.booleanity.eval.RamRa_2"]), stage6_field_expr("stage6.booleanity.output.term37.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term37.boolean_zero.square", "stage6.booleanity.eval.RamRa_2"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_74", Stage6FieldExprKind::Pow(74), &["stage6.booleanity.gamma"]),
+    stage6_field_expr("stage6.booleanity.output.term37", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_74", "stage6.booleanity.output.term37.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term38.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.RamRa_3", "stage6.booleanity.eval.RamRa_3"]), stage6_field_expr("stage6.booleanity.output.term38.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term38.boolean_zero.square", "stage6.booleanity.eval.RamRa_3"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_76", Stage6FieldExprKind::Pow(76), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term38", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_76", "stage6.booleanity.output.term38.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.booleanity.output.term0", "stage6.booleanity.output.term1", "stage6.booleanity.output.term2", "stage6.booleanity.output.term3", "stage6.booleanity.output.term4", "stage6.booleanity.output.term5", "stage6.booleanity.output.term6", "stage6.booleanity.output.term7", "stage6.booleanity.output.term8", "stage6.booleanity.output.term9", "stage6.booleanity.output.term10", "stage6.booleanity.output.term11", "stage6.booleanity.output.term12", "stage6.booleanity.output.term13", "stage6.booleanity.output.term14", "stage6.booleanity.output.term15", "stage6.booleanity.output.term16", "stage6.booleanity.output.term17", "stage6.booleanity.output.term18", "stage6.booleanity.output.term19", "stage6.booleanity.output.term20", "stage6.booleanity.output.term21", "stage6.booleanity.output.term22", "stage6.booleanity.output.term23", "stage6.booleanity.output.term24", "stage6.booleanity.output.term25", "stage6.booleanity.output.term26", "stage6.booleanity.output.term27", "stage6.booleanity.output.term28", "stage6.booleanity.output.term29", "stage6.booleanity.output.term30", "stage6.booleanity.output.term31", "stage6.booleanity.output.term32", "stage6.booleanity.output.term33", "stage6.booleanity.output.term34", "stage6.booleanity.output.term35", "stage6.booleanity.output.term36", "stage6.booleanity.output.term37", "stage6.booleanity.output.term38"]), stage6_field_expr("stage6.hamming_booleanity.output.term0.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.eval.HammingWeight", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.term0.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.hamming_booleanity.output.term0.boolean_zero.square", "stage6.hamming_booleanity.eval.HammingWeight"]),
+    stage6_field_expr("stage6.hamming_booleanity.output.term0", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.output.term0.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.hamming_booleanity.output.term0"]), stage6_field_expr("stage6.inc_claim_reduction.output.term0", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamIncStage2"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term1", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.gamma_pow_1", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term2", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]),
+    stage6_field_expr("stage6.inc_claim_reduction.output.term3", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_3", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.inc_claim_reduction.output.term0", "stage6.inc_claim_reduction.output.term1", "stage6.inc_claim_reduction.output.term2", "stage6.inc_claim_reduction.output.term3"]), stage6_field_expr("stage6.ram_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3", "stage6.ram_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.ram_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.ram_ra_virtual.output.term0"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term1", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_1", "stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]),
+    stage6_field_expr("stage6.instruction_ra_virtual.output.term2", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term3", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term4", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term5", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]),
+    stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), stage6_field_expr("stage6.bytecode_read_raf.output.contribution", Stage6FieldExprKind::Sum, &["stage6.bytecode_read_raf.output.term.Stage1", "stage6.bytecode_read_raf.output.term.Stage2", "stage6.bytecode_read_raf.output.term.Stage3", "stage6.bytecode_read_raf.output.term.Stage4", "stage6.bytecode_read_raf.output.term.Stage5", "stage6.bytecode_read_raf.output.term.Entry"]), stage6_field_expr("stage6.bytecode_read_raf.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.output.product.BytecodeRa"]),
+];
+const fn stage6_scalar_expr(symbol: &'static str, kind: Stage6ScalarExprKind, operands: &'static [&'static str]) -> Stage6ScalarExprPlan {
+    Stage6ScalarExprPlan { symbol, kind, operands }
+}
+
+#[rustfmt::skip]
+pub const STAGE6_SCALAR_EXPRS: &[Stage6ScalarExprPlan] = &[
+    stage6_scalar_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6ScalarExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), stage6_scalar_expr("stage6.booleanity.output.eq.InstructionRa0", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.booleanity.instance", "stage6.booleanity.output.point"]), stage6_scalar_expr("stage6.hamming_booleanity.output.eq.LookupOutput", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse } }, &["stage6.hamming_booleanity.instance", "stage6.input.stage1.LookupOutput"]), stage6_scalar_expr("stage6.ram_ra_virtual.output.eq.Cycle", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.ram_ra_virtual.instance", "stage6.input.stage5.ram_ra_claim_reduction.RamRa"]), stage6_scalar_expr("stage6.instruction_ra_virtual.output.eq.Cycle", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.instruction_ra_virtual.instance", "stage6.input.stage5.instruction_read_raf.InstructionRa_0"]), stage6_scalar_expr("stage6.inc_claim_reduction.output.eq.RamIncStage2", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage2.ram_read_write.RamInc"]), stage6_scalar_expr("stage6.inc_claim_reduction.output.eq.RamIncStage4", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_scalar_expr("stage6.inc_claim_reduction.output.eq.RdIncStage4", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_scalar_expr("stage6.inc_claim_reduction.output.eq.RdIncStage5", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage5.registers_val_evaluation.RdInc"]),
 ];
 pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[
 
 ];
 
 pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[
-    Stage6SumcheckClaimPlan { symbol: "stage6.bytecode_read_raf.input", stage: "stage6", domain: "jolt.stage6_bytecode_read_raf_domain", num_rounds: 26, degree: 4, claim: "stage6.bytecode_read_raf.weighted_prior_stage_values", kernel: None, relation: Some("jolt.stage6.bytecode_read_raf"), claim_value: "stage6.bytecode_read_raf.claim_expr.partial76", input_openings: "stage6.input.stage1.UnexpandedPC|stage6.input.stage1.Imm|stage6.input.stage1.OpFlagAddOperands|stage6.input.stage1.OpFlagSubtractOperands|stage6.input.stage1.OpFlagMultiplyOperands|stage6.input.stage1.OpFlagLoad|stage6.input.stage1.OpFlagStore|stage6.input.stage1.OpFlagJump|stage6.input.stage1.OpFlagWriteLookupOutputToRD|stage6.input.stage1.OpFlagVirtualInstruction|stage6.input.stage1.OpFlagAssert|stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC|stage6.input.stage1.OpFlagAdvice|stage6.input.stage1.OpFlagIsCompressed|stage6.input.stage1.OpFlagIsFirstInSequence|stage6.input.stage1.OpFlagIsLastInSequence|stage6.input.stage2.OpFlagJump|stage6.input.stage2.InstructionFlagBranch|stage6.input.stage2.OpFlagWriteLookupOutputToRD|stage6.input.stage2.OpFlagVirtualInstruction|stage6.input.stage3.instruction_input.Imm|stage6.input.stage3.spartan_shift.UnexpandedPC|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm|stage6.input.stage3.spartan_shift.InstructionFlagIsNoop|stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction|stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence|stage6.input.stage4.RdWa|stage6.input.stage4.Rs1Ra|stage6.input.stage4.Rs2Ra|stage6.input.stage5.registers_val_evaluation.RdWa|stage6.input.stage5.InstructionRafFlag|stage6.input.stage5.LookupTableFlag_0|stage6.input.stage5.LookupTableFlag_1|stage6.input.stage5.LookupTableFlag_2|stage6.input.stage5.LookupTableFlag_3|stage6.input.stage5.LookupTableFlag_4|stage6.input.stage5.LookupTableFlag_5|stage6.input.stage5.LookupTableFlag_6|stage6.input.stage5.LookupTableFlag_7|stage6.input.stage5.LookupTableFlag_8|stage6.input.stage5.LookupTableFlag_9|stage6.input.stage5.LookupTableFlag_10|stage6.input.stage5.LookupTableFlag_11|stage6.input.stage5.LookupTableFlag_12|stage6.input.stage5.LookupTableFlag_13|stage6.input.stage5.LookupTableFlag_14|stage6.input.stage5.LookupTableFlag_15|stage6.input.stage5.LookupTableFlag_16|stage6.input.stage5.LookupTableFlag_17|stage6.input.stage5.LookupTableFlag_18|stage6.input.stage5.LookupTableFlag_19|stage6.input.stage5.LookupTableFlag_20|stage6.input.stage5.LookupTableFlag_21|stage6.input.stage5.LookupTableFlag_22|stage6.input.stage5.LookupTableFlag_23|stage6.input.stage5.LookupTableFlag_24|stage6.input.stage5.LookupTableFlag_25|stage6.input.stage5.LookupTableFlag_26|stage6.input.stage5.LookupTableFlag_27|stage6.input.stage5.LookupTableFlag_28|stage6.input.stage5.LookupTableFlag_29|stage6.input.stage5.LookupTableFlag_30|stage6.input.stage5.LookupTableFlag_31|stage6.input.stage5.LookupTableFlag_32|stage6.input.stage5.LookupTableFlag_33|stage6.input.stage5.LookupTableFlag_34|stage6.input.stage5.LookupTableFlag_35|stage6.input.stage5.LookupTableFlag_36|stage6.input.stage5.LookupTableFlag_37|stage6.input.stage5.LookupTableFlag_38|stage6.input.stage5.LookupTableFlag_39|stage6.input.stage5.LookupTableFlag_40|stage6.input.stage1.PC|stage6.input.stage3.spartan_shift.PC" },
-    Stage6SumcheckClaimPlan { symbol: "stage6.booleanity.input", stage: "stage6", domain: "jolt.stage6_booleanity_domain", num_rounds: 20, degree: 3, claim: "stage6.booleanity.zero", kernel: None, relation: Some("jolt.stage6.booleanity"), claim_value: "stage6.zero", input_openings: "" },
-    Stage6SumcheckClaimPlan { symbol: "stage6.hamming_booleanity.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage6.hamming_booleanity.zero", kernel: None, relation: Some("jolt.stage6.hamming_booleanity"), claim_value: "stage6.zero", input_openings: "stage6.input.stage1.LookupOutput" },
-    Stage6SumcheckClaimPlan { symbol: "stage6.ram_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.ram_ra_virtual.weighted_ram_ra", kernel: None, relation: Some("jolt.stage6.ram_ra_virtual"), claim_value: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", input_openings: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" },
-    Stage6SumcheckClaimPlan { symbol: "stage6.instruction_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.instruction_ra_virtual.weighted_instruction_ra", kernel: None, relation: Some("jolt.stage6.instruction_ra_virtual"), claim_value: "stage6.instruction_ra_virtual.claim_expr.partial6", input_openings: "stage6.input.stage5.instruction_read_raf.InstructionRa_0|stage6.input.stage5.instruction_read_raf.InstructionRa_1|stage6.input.stage5.instruction_read_raf.InstructionRa_2|stage6.input.stage5.instruction_read_raf.InstructionRa_3|stage6.input.stage5.instruction_read_raf.InstructionRa_4|stage6.input.stage5.instruction_read_raf.InstructionRa_5|stage6.input.stage5.instruction_read_raf.InstructionRa_6|stage6.input.stage5.instruction_read_raf.InstructionRa_7" },
-    Stage6SumcheckClaimPlan { symbol: "stage6.inc_claim_reduction.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage6.inc_claim_reduction.weighted_increments", kernel: None, relation: Some("jolt.stage6.inc_claim_reduction"), claim_value: "stage6.inc_claim_reduction.claim_expr.partial2", input_openings: "stage6.input.stage2.ram_read_write.RamInc|stage6.input.stage4.ram_val_check.RamInc|stage6.input.stage4.registers_read_write.RdInc|stage6.input.stage5.registers_val_evaluation.RdInc" },
+    Stage6SumcheckClaimPlan { symbol: "stage6.bytecode_read_raf.input", stage: "stage6", domain: "jolt.stage6_bytecode_read_raf_domain", num_rounds: 26, degree: 4, claim: "stage6.bytecode_read_raf.weighted_prior_stage_values", kernel: None, relation: Some(Stage6RelationKind::Stage6BytecodeReadRaf), claim_value: "stage6.bytecode_read_raf.claim_expr.partial76" },
+    Stage6SumcheckClaimPlan { symbol: "stage6.booleanity.input", stage: "stage6", domain: "jolt.stage6_booleanity_domain", num_rounds: 20, degree: 3, claim: "stage6.booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6Booleanity), claim_value: "stage6.zero" },
+    Stage6SumcheckClaimPlan { symbol: "stage6.hamming_booleanity.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage6.hamming_booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6HammingBooleanity), claim_value: "stage6.zero" },
+    Stage6SumcheckClaimPlan { symbol: "stage6.ram_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.ram_ra_virtual.weighted_ram_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6RamRaVirtual), claim_value: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" },
+    Stage6SumcheckClaimPlan { symbol: "stage6.instruction_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.instruction_ra_virtual.weighted_instruction_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6InstructionRaVirtual), claim_value: "stage6.instruction_ra_virtual.claim_expr.partial6" },
+    Stage6SumcheckClaimPlan { symbol: "stage6.inc_claim_reduction.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage6.inc_claim_reduction.weighted_increments", kernel: None, relation: Some(Stage6RelationKind::Stage6IncClaimReduction), claim_value: "stage6.inc_claim_reduction.claim_expr.partial2" },
 ];
-pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    10,
-    16,
+pub const STAGE6_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[
+    "stage6.bytecode_read_raf.input",
+    "stage6.booleanity.input",
+    "stage6.hamming_booleanity.input",
+    "stage6.ram_ra_virtual.input",
+    "stage6.instruction_ra_virtual.input",
+    "stage6.inc_claim_reduction.input",
 ];
 
+pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[10, 16];
+
 pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[
-    Stage6SumcheckBatchPlan { symbol: "stage6.batch", stage: "stage6", proof_slot: "stage6.sumcheck", policy: "jolt_core_stage6_aligned", count: 6, ordered_claims: "stage6.bytecode_read_raf.input|stage6.booleanity.input|stage6.hamming_booleanity.input|stage6.ram_ra_virtual.input|stage6.instruction_ra_virtual.input|stage6.inc_claim_reduction.input", claim_operands: "stage6.bytecode_read_raf.input|stage6.booleanity.input|stage6.hamming_booleanity.input|stage6.ram_ra_virtual.input|stage6.instruction_ra_virtual.input|stage6.inc_claim_reduction.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
-];
-pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    10,
-    16,
+    Stage6SumcheckBatchPlan { symbol: "stage6.batch", stage: "stage6", proof_slot: "stage6.sumcheck", policy: "jolt_core_stage6_aligned", count: 6, claim_operands: STAGE6_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
+pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[10, 16];
 
 pub const STAGE6_SUMCHECK_DRIVERS: &[Stage6SumcheckDriverPlan] = &[
-    Stage6SumcheckDriverPlan { symbol: "stage6.sumcheck", stage: "stage6", proof_slot: "stage6.sumcheck", kernel: None, relation: Some("jolt.stage6.batched"), batch: "stage6.batch", policy: "jolt_core_stage6_aligned", round_schedule: STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 26, degree: 5 },
+    Stage6SumcheckDriverPlan { symbol: "stage6.sumcheck", stage: "stage6", proof_slot: "stage6.sumcheck", kernel: None, relation: Some(Stage6RelationKind::Stage6Batched), batch: "stage6.batch", policy: "jolt_core_stage6_aligned", round_schedule: STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 26, degree: 5 },
 ];
 pub const STAGE6_SUMCHECK_INSTANCE_RESULTS: &[Stage6SumcheckInstanceResultPlan] = &[
-    Stage6SumcheckInstanceResultPlan { symbol: "stage6.bytecode_read_raf.instance", source: "stage6.sumcheck", claim: "stage6.bytecode_read_raf.input", relation: "jolt.stage6.bytecode_read_raf", index: 0, point_arity: 26, num_rounds: 26, round_offset: 0, point_order: "bytecode_read_raf", degree: 4 },
-    Stage6SumcheckInstanceResultPlan { symbol: "stage6.booleanity.instance", source: "stage6.sumcheck", claim: "stage6.booleanity.input", relation: "jolt.stage6.booleanity", index: 1, point_arity: 20, num_rounds: 20, round_offset: 6, point_order: "stage6_booleanity", degree: 3 },
-    Stage6SumcheckInstanceResultPlan { symbol: "stage6.hamming_booleanity.instance", source: "stage6.sumcheck", claim: "stage6.hamming_booleanity.input", relation: "jolt.stage6.hamming_booleanity", index: 2, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 3 },
-    Stage6SumcheckInstanceResultPlan { symbol: "stage6.ram_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.ram_ra_virtual.input", relation: "jolt.stage6.ram_ra_virtual", index: 3, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 5 },
-    Stage6SumcheckInstanceResultPlan { symbol: "stage6.instruction_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.instruction_ra_virtual.input", relation: "jolt.stage6.instruction_ra_virtual", index: 4, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 5 },
-    Stage6SumcheckInstanceResultPlan { symbol: "stage6.inc_claim_reduction.instance", source: "stage6.sumcheck", claim: "stage6.inc_claim_reduction.input", relation: "jolt.stage6.inc_claim_reduction", index: 5, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 2 },
+    Stage6SumcheckInstanceResultPlan { symbol: "stage6.bytecode_read_raf.instance", source: "stage6.sumcheck", claim: "stage6.bytecode_read_raf.input", relation: Stage6RelationKind::Stage6BytecodeReadRaf, index: 0, point_arity: 26, num_rounds: 26, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::RelationLocal, degree: 4 },
+    Stage6SumcheckInstanceResultPlan { symbol: "stage6.booleanity.instance", source: "stage6.sumcheck", claim: "stage6.booleanity.input", relation: Stage6RelationKind::Stage6Booleanity, index: 1, point_arity: 20, num_rounds: 20, round_offset: 6, point_order: bolt_verifier_runtime::SumcheckPointOrder::AsIs, degree: 3 },
+    Stage6SumcheckInstanceResultPlan { symbol: "stage6.hamming_booleanity.instance", source: "stage6.sumcheck", claim: "stage6.hamming_booleanity.input", relation: Stage6RelationKind::Stage6HammingBooleanity, index: 2, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 },
+    Stage6SumcheckInstanceResultPlan { symbol: "stage6.ram_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.ram_ra_virtual.input", relation: Stage6RelationKind::Stage6RamRaVirtual, index: 3, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 5 },
+    Stage6SumcheckInstanceResultPlan { symbol: "stage6.instruction_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.instruction_ra_virtual.input", relation: Stage6RelationKind::Stage6InstructionRaVirtual, index: 4, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 5 },
+    Stage6SumcheckInstanceResultPlan { symbol: "stage6.inc_claim_reduction.instance", source: "stage6.sumcheck", claim: "stage6.inc_claim_reduction.input", relation: Stage6RelationKind::Stage6IncClaimReduction, index: 5, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 },
 ];
 
-macro_rules! stage6_sumcheck_eval {
-    ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => {
-        Stage6SumcheckEvalPlan { symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle }
-    };
+const fn stage6_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage6SumcheckEvalPlan {
+    Stage6SumcheckEvalPlan { symbol, source, name, index, oracle }
 }
 
 #[rustfmt::skip]
 pub const STAGE6_SUMCHECK_EVALS: &[Stage6SumcheckEvalPlan] = &[
-    stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_0", 0, "BytecodeRa_0"), stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_1", 1, "BytecodeRa_1"), stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_2", 2, "BytecodeRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_0", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_0", 0, "InstructionRa_0"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_1", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_2", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_3", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_4", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_4", 4, "InstructionRa_4"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_5", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_6", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_7", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_8", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_8", 8, "InstructionRa_8"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_9", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_10", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_11", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_12", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_12", 12, "InstructionRa_12"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_13", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_14", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_15", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_16", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_16", 16, "InstructionRa_16"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_17", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_18", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_19", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_20", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_20", 20, "InstructionRa_20"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_21", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_22", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_23", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_24", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_24", 24, "InstructionRa_24"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_25", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_26", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_27", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_28", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_28", 28, "InstructionRa_28"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_29", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_30", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_31", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_0", 32, "BytecodeRa_0"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_0", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_0", 35, "RamRa_0"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_1", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_1", 36, "RamRa_1"),
-    stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_2", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_2", 37, "RamRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_3", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_3", 38, "RamRa_3"), stage6_sumcheck_eval!("stage6.hamming_booleanity.eval.HammingWeight", "stage6.sumcheck", "stage6.hamming_booleanity.eval.HammingWeight", 0, "HammingWeight"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_0", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_0", 0, "RamRa_0"),
-    stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_1", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_1", 1, "RamRa_1"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_2", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_2", 2, "RamRa_2"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_3", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_3", 3, "RamRa_3"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_0", 0, "InstructionRa_0"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_4", 4, "InstructionRa_4"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_8", 8, "InstructionRa_8"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_12", 12, "InstructionRa_12"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_16", 16, "InstructionRa_16"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_20", 20, "InstructionRa_20"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_24", 24, "InstructionRa_24"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_28", 28, "InstructionRa_28"),
-    stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval!("stage6.inc_claim_reduction.eval.RamInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RamInc", 0, "RamInc"),
-    stage6_sumcheck_eval!("stage6.inc_claim_reduction.eval.RdInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RdInc", 1, "RdInc"),
+    stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_0", 0, "BytecodeRa_0"), stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_1", 1, "BytecodeRa_1"), stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_2", 2, "BytecodeRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_0", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_0", 0, "InstructionRa_0"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_1", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_2", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_3", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_4", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_4", 4, "InstructionRa_4"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_5", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_6", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_7", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_8", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_8", 8, "InstructionRa_8"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_9", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_10", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_11", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_12", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_12", 12, "InstructionRa_12"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_13", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_14", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_15", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_16", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_16", 16, "InstructionRa_16"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_17", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_18", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_19", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_20", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_20", 20, "InstructionRa_20"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_21", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_22", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_23", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_24", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_24", 24, "InstructionRa_24"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_25", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_26", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_27", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_28", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_28", 28, "InstructionRa_28"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_29", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_30", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_31", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_0", 32, "BytecodeRa_0"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_0", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_0", 35, "RamRa_0"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_1", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_1", 36, "RamRa_1"),
+    stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_2", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_2", 37, "RamRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_3", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_3", 38, "RamRa_3"), stage6_sumcheck_eval("stage6.hamming_booleanity.eval.HammingWeight", "stage6.sumcheck", "stage6.hamming_booleanity.eval.HammingWeight", 0, "HammingWeight"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_0", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_0", 0, "RamRa_0"),
+    stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_1", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_1", 1, "RamRa_1"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_2", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_2", 2, "RamRa_2"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_3", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_3", 3, "RamRa_3"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_0", 0, "InstructionRa_0"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_4", 4, "InstructionRa_4"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_8", 8, "InstructionRa_8"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_12", 12, "InstructionRa_12"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_16", 16, "InstructionRa_16"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_20", 20, "InstructionRa_20"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_24", 24, "InstructionRa_24"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_28", 28, "InstructionRa_28"),
+    stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval("stage6.inc_claim_reduction.eval.RamInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RamInc", 0, "RamInc"),
+    stage6_sumcheck_eval("stage6.inc_claim_reduction.eval.RdInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RdInc", 1, "RdInc"),
 ];
 
-pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[
-    Stage6PointZeroPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad", field: "bn254_fr", arity: 2 },
+pub const STAGE6_POINT_EXPRS: &[Stage6PointExprPlan] = &[
+    Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad", kind: Stage6PointExprKind::Zero { field: "bn254_fr", arity: 2 }, operands: &[] },
+    Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.Cycle", kind: Stage6PointExprKind::Slice { offset: 10, length: 16 }, operands: &["stage6.bytecode_read_raf.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.source", kind: Stage6PointExprKind::Slice { offset: 0, length: 2 }, operands: &["stage6.bytecode_read_raf.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1.address", kind: Stage6PointExprKind::Slice { offset: 2, length: 4 }, operands: &["stage6.bytecode_read_raf.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2.address", kind: Stage6PointExprKind::Slice { offset: 6, length: 4 }, operands: &["stage6.bytecode_read_raf.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] },
+    Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] },
+    Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] },
+    Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_1"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_1"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_1"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_1"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_2"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_2"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_2"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_2"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_3"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_3"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_3"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_3"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_4"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_4"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_4"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_4"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_5"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_5"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_5"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_5"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_6"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_6"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_6"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_6"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_7"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_7"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_7"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_7"] },
+    Stage6PointExprPlan { symbol: "stage6.booleanity.output.point.Address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] },
+    Stage6PointExprPlan { symbol: "stage6.booleanity.output.point.Cycle", kind: Stage6PointExprKind::Slice { offset: 16, length: 16 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] },
+    Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address", kind: Stage6PointExprKind::Concat { layout: "left_zero_padded_address_chunk", arity: 4 }, operands: &["stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad", "stage6.bytecode_read_raf.point.BytecodeRa_0.address.source"] },
+    Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.bytecode_read_raf.point.BytecodeRa_0.address", "stage6.bytecode_read_raf.point.Cycle"] },
+    Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.bytecode_read_raf.point.BytecodeRa_1.address", "stage6.bytecode_read_raf.point.Cycle"] },
+    Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.bytecode_read_raf.point.BytecodeRa_2.address", "stage6.bytecode_read_raf.point.Cycle"] },
+    Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.ram_ra_virtual.point.RamRa_0.address", "stage6.ram_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.ram_ra_virtual.point.RamRa_1.address", "stage6.ram_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.ram_ra_virtual.point.RamRa_2.address", "stage6.ram_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.ram_ra_virtual.point.RamRa_3.address", "stage6.ram_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_0.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_1.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_2.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_3.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_4.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_5.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_6.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_7.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_8.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_9.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_10.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_11.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_12.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_13.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_14.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_15.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_16.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_17.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_18.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_19.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_20.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_21.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_22.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_23.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_24.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_25.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_26.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_27.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_28.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_29.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_30.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_31.address", "stage6.instruction_ra_virtual.instance"] },
+    Stage6PointExprPlan { symbol: "stage6.booleanity.output.point", kind: Stage6PointExprKind::Concat { layout: "address_prefix_then_cycle", arity: 20 }, operands: &["stage6.booleanity.output.point.Address", "stage6.booleanity.output.point.Cycle"] },
 ];
 
-pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[
-    Stage6PointSlicePlan { symbol: "stage6.bytecode_read_raf.point.Cycle", source: "stage6.bytecode_read_raf.instance", offset: 10, length: 16, input: "stage6.bytecode_read_raf.instance" },
-    Stage6PointSlicePlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.source", source: "stage6.bytecode_read_raf.instance", offset: 0, length: 2, input: "stage6.bytecode_read_raf.instance" },
-    Stage6PointSlicePlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1.address", source: "stage6.bytecode_read_raf.instance", offset: 2, length: 4, input: "stage6.bytecode_read_raf.instance" },
-    Stage6PointSlicePlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2.address", source: "stage6.bytecode_read_raf.instance", offset: 6, length: 4, input: "stage6.bytecode_read_raf.instance" },
-    Stage6PointSlicePlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0.address", source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", offset: 0, length: 4, input: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" },
-    Stage6PointSlicePlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1.address", source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", offset: 4, length: 4, input: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" },
-    Stage6PointSlicePlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2.address", source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", offset: 8, length: 4, input: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" },
-    Stage6PointSlicePlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3.address", source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", offset: 12, length: 4, input: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_1" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_1" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_1" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_1" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_2" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_2" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_2" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_2" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_3" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_3" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_3" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_3" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_4" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_4" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_4" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_4" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_5" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_5" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_5" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_5" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_6" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_6" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_6" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_6" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" },
-    Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" },
-];
-
-pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[
-    Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address", layout: "left_zero_padded_address_chunk", arity: 4, inputs: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad|stage6.bytecode_read_raf.point.BytecodeRa_0.address.source" },
-    Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.bytecode_read_raf.point.BytecodeRa_0.address|stage6.bytecode_read_raf.point.Cycle" },
-    Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.bytecode_read_raf.point.BytecodeRa_1.address|stage6.bytecode_read_raf.point.Cycle" },
-    Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.bytecode_read_raf.point.BytecodeRa_2.address|stage6.bytecode_read_raf.point.Cycle" },
-    Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.ram_ra_virtual.point.RamRa_0.address|stage6.ram_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.ram_ra_virtual.point.RamRa_1.address|stage6.ram_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.ram_ra_virtual.point.RamRa_2.address|stage6.ram_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.ram_ra_virtual.point.RamRa_3.address|stage6.ram_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_0.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_1.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_2.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_3.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_4.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_5.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_6.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_7.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_8.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_9.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_10.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_11.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_12.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_13.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_14.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_15.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_16.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_17.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_18.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_19.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_20.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_21.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_22.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_23.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_24.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_25.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_26.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_27.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_28.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_29.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_30.address|stage6.instruction_ra_virtual.instance" },
-    Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_31.address|stage6.instruction_ra_virtual.instance" },
-];
 pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[
-    Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.bytecode_read_raf.point.BytecodeRa_0", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_0" },
-    Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.bytecode_read_raf.point.BytecodeRa_1", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_1" },
-    Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.bytecode_read_raf.point.BytecodeRa_2", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_2" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_0" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_1" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_2" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_3" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_4" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_5" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_6" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_7" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_8" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_9" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_10" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_11" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_12" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_13" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_14" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_15" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_16" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_17" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_18" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_19" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_20" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_21" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_22" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_23" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_24" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_25" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_26" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_27" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_28" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_29" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_30" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_31" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_0" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_1" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_2" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_0" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_1" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_2" },
-    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_3" },
-    Stage6OpeningClaimPlan { symbol: "stage6.hamming_booleanity.opening.HammingWeight", oracle: "HammingWeight", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage6.hamming_booleanity.instance", eval_source: "stage6.hamming_booleanity.eval.HammingWeight" },
-    Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.ram_ra_virtual.point.RamRa_0", eval_source: "stage6.ram_ra_virtual.eval.RamRa_0" },
-    Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.ram_ra_virtual.point.RamRa_1", eval_source: "stage6.ram_ra_virtual.eval.RamRa_1" },
-    Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.ram_ra_virtual.point.RamRa_2", eval_source: "stage6.ram_ra_virtual.eval.RamRa_2" },
-    Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.ram_ra_virtual.point.RamRa_3", eval_source: "stage6.ram_ra_virtual.eval.RamRa_3" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_0", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_0" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_1", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_1" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_2", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_2" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_3", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_3" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_4", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_4" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_5", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_5" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_6", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_6" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_7", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_7" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_8", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_8" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_9", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_9" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_10", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_10" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_11", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_11" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_12", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_12" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_13", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_13" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_14", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_14" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_15", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_15" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_16", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_16" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_17", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_17" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_18", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_18" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_19", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_19" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_20", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_20" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_21", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_21" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_22", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_22" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_23", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_23" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_24", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_24" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_25", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_25" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_26", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_26" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_27", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_27" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_28", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_28" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_29", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_29" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_30", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_30" },
-    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_31", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_31" },
-    Stage6OpeningClaimPlan { symbol: "stage6.inc_claim_reduction.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage6.inc_claim_reduction.instance", eval_source: "stage6.inc_claim_reduction.eval.RamInc" },
-    Stage6OpeningClaimPlan { symbol: "stage6.inc_claim_reduction.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage6.inc_claim_reduction.instance", eval_source: "stage6.inc_claim_reduction.eval.RdInc" },
+    Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_0", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_0" },
+    Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_1", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_1" },
+    Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_2", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_2" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_0" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_1" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_2" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_3" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_4" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_5" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_6" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_7" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_8" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_9" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_10" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_11" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_12" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_13" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_14" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_15" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_16" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_17" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_18" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_19" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_20" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_21" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_22" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_23" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_24" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_25" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_26" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_27" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_28" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_29" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_30" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_31" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_0" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_1" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_2" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_0" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_1" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_2" },
+    Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_3" },
+    Stage6OpeningClaimPlan { symbol: "stage6.hamming_booleanity.opening.HammingWeight", oracle: "HammingWeight", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual, point_source: "stage6.hamming_booleanity.instance", eval_source: "stage6.hamming_booleanity.eval.HammingWeight" },
+    Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.ram_ra_virtual.point.RamRa_0", eval_source: "stage6.ram_ra_virtual.eval.RamRa_0" },
+    Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.ram_ra_virtual.point.RamRa_1", eval_source: "stage6.ram_ra_virtual.eval.RamRa_1" },
+    Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.ram_ra_virtual.point.RamRa_2", eval_source: "stage6.ram_ra_virtual.eval.RamRa_2" },
+    Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.ram_ra_virtual.point.RamRa_3", eval_source: "stage6.ram_ra_virtual.eval.RamRa_3" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_0", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_0" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_1", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_1" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_2", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_2" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_3", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_3" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_4", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_4" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_5", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_5" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_6", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_6" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_7", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_7" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_8", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_8" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_9", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_9" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_10", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_10" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_11", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_11" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_12", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_12" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_13", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_13" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_14", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_14" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_15", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_15" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_16", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_16" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_17", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_17" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_18", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_18" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_19", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_19" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_20", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_20" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_21", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_21" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_22", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_22" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_23", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_23" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_24", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_24" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_25", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_25" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_26", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_26" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_27", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_27" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_28", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_28" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_29", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_29" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_30", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_30" },
+    Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_31", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_31" },
+    Stage6OpeningClaimPlan { symbol: "stage6.inc_claim_reduction.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.inc_claim_reduction.instance", eval_source: "stage6.inc_claim_reduction.eval.RamInc" },
+    Stage6OpeningClaimPlan { symbol: "stage6.inc_claim_reduction.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.inc_claim_reduction.instance", eval_source: "stage6.inc_claim_reduction.eval.RdInc" },
 ];
 
 pub const STAGE6_OPENING_EQUALITIES: &[Stage6OpeningClaimEqualityPlan] = &[
@@ -593,29 +580,128 @@ pub const STAGE6_OPENING_EQUALITIES: &[Stage6OpeningClaimEqualityPlan] = &[
 ];
 
 pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[
-    Stage6OpeningBatchPlan { symbol: "stage6.openings", stage: "stage6", proof_slot: "stage6.openings", policy: "jolt_stage6_output_order", count: 81, ordered_claims: "stage6.bytecode_read_raf.opening.BytecodeRa_0|stage6.bytecode_read_raf.opening.BytecodeRa_1|stage6.bytecode_read_raf.opening.BytecodeRa_2|stage6.booleanity.opening.InstructionRa_0|stage6.booleanity.opening.InstructionRa_1|stage6.booleanity.opening.InstructionRa_2|stage6.booleanity.opening.InstructionRa_3|stage6.booleanity.opening.InstructionRa_4|stage6.booleanity.opening.InstructionRa_5|stage6.booleanity.opening.InstructionRa_6|stage6.booleanity.opening.InstructionRa_7|stage6.booleanity.opening.InstructionRa_8|stage6.booleanity.opening.InstructionRa_9|stage6.booleanity.opening.InstructionRa_10|stage6.booleanity.opening.InstructionRa_11|stage6.booleanity.opening.InstructionRa_12|stage6.booleanity.opening.InstructionRa_13|stage6.booleanity.opening.InstructionRa_14|stage6.booleanity.opening.InstructionRa_15|stage6.booleanity.opening.InstructionRa_16|stage6.booleanity.opening.InstructionRa_17|stage6.booleanity.opening.InstructionRa_18|stage6.booleanity.opening.InstructionRa_19|stage6.booleanity.opening.InstructionRa_20|stage6.booleanity.opening.InstructionRa_21|stage6.booleanity.opening.InstructionRa_22|stage6.booleanity.opening.InstructionRa_23|stage6.booleanity.opening.InstructionRa_24|stage6.booleanity.opening.InstructionRa_25|stage6.booleanity.opening.InstructionRa_26|stage6.booleanity.opening.InstructionRa_27|stage6.booleanity.opening.InstructionRa_28|stage6.booleanity.opening.InstructionRa_29|stage6.booleanity.opening.InstructionRa_30|stage6.booleanity.opening.InstructionRa_31|stage6.booleanity.opening.BytecodeRa_0|stage6.booleanity.opening.BytecodeRa_1|stage6.booleanity.opening.BytecodeRa_2|stage6.booleanity.opening.RamRa_0|stage6.booleanity.opening.RamRa_1|stage6.booleanity.opening.RamRa_2|stage6.booleanity.opening.RamRa_3|stage6.hamming_booleanity.opening.HammingWeight|stage6.ram_ra_virtual.opening.RamRa_0|stage6.ram_ra_virtual.opening.RamRa_1|stage6.ram_ra_virtual.opening.RamRa_2|stage6.ram_ra_virtual.opening.RamRa_3|stage6.instruction_ra_virtual.opening.InstructionRa_0|stage6.instruction_ra_virtual.opening.InstructionRa_1|stage6.instruction_ra_virtual.opening.InstructionRa_2|stage6.instruction_ra_virtual.opening.InstructionRa_3|stage6.instruction_ra_virtual.opening.InstructionRa_4|stage6.instruction_ra_virtual.opening.InstructionRa_5|stage6.instruction_ra_virtual.opening.InstructionRa_6|stage6.instruction_ra_virtual.opening.InstructionRa_7|stage6.instruction_ra_virtual.opening.InstructionRa_8|stage6.instruction_ra_virtual.opening.InstructionRa_9|stage6.instruction_ra_virtual.opening.InstructionRa_10|stage6.instruction_ra_virtual.opening.InstructionRa_11|stage6.instruction_ra_virtual.opening.InstructionRa_12|stage6.instruction_ra_virtual.opening.InstructionRa_13|stage6.instruction_ra_virtual.opening.InstructionRa_14|stage6.instruction_ra_virtual.opening.InstructionRa_15|stage6.instruction_ra_virtual.opening.InstructionRa_16|stage6.instruction_ra_virtual.opening.InstructionRa_17|stage6.instruction_ra_virtual.opening.InstructionRa_18|stage6.instruction_ra_virtual.opening.InstructionRa_19|stage6.instruction_ra_virtual.opening.InstructionRa_20|stage6.instruction_ra_virtual.opening.InstructionRa_21|stage6.instruction_ra_virtual.opening.InstructionRa_22|stage6.instruction_ra_virtual.opening.InstructionRa_23|stage6.instruction_ra_virtual.opening.InstructionRa_24|stage6.instruction_ra_virtual.opening.InstructionRa_25|stage6.instruction_ra_virtual.opening.InstructionRa_26|stage6.instruction_ra_virtual.opening.InstructionRa_27|stage6.instruction_ra_virtual.opening.InstructionRa_28|stage6.instruction_ra_virtual.opening.InstructionRa_29|stage6.instruction_ra_virtual.opening.InstructionRa_30|stage6.instruction_ra_virtual.opening.InstructionRa_31|stage6.inc_claim_reduction.opening.RamInc|stage6.inc_claim_reduction.opening.RdInc", claim_operands: "stage6.bytecode_read_raf.opening.BytecodeRa_0|stage6.bytecode_read_raf.opening.BytecodeRa_1|stage6.bytecode_read_raf.opening.BytecodeRa_2|stage6.booleanity.opening.InstructionRa_0|stage6.booleanity.opening.InstructionRa_1|stage6.booleanity.opening.InstructionRa_2|stage6.booleanity.opening.InstructionRa_3|stage6.booleanity.opening.InstructionRa_4|stage6.booleanity.opening.InstructionRa_5|stage6.booleanity.opening.InstructionRa_6|stage6.booleanity.opening.InstructionRa_7|stage6.booleanity.opening.InstructionRa_8|stage6.booleanity.opening.InstructionRa_9|stage6.booleanity.opening.InstructionRa_10|stage6.booleanity.opening.InstructionRa_11|stage6.booleanity.opening.InstructionRa_12|stage6.booleanity.opening.InstructionRa_13|stage6.booleanity.opening.InstructionRa_14|stage6.booleanity.opening.InstructionRa_15|stage6.booleanity.opening.InstructionRa_16|stage6.booleanity.opening.InstructionRa_17|stage6.booleanity.opening.InstructionRa_18|stage6.booleanity.opening.InstructionRa_19|stage6.booleanity.opening.InstructionRa_20|stage6.booleanity.opening.InstructionRa_21|stage6.booleanity.opening.InstructionRa_22|stage6.booleanity.opening.InstructionRa_23|stage6.booleanity.opening.InstructionRa_24|stage6.booleanity.opening.InstructionRa_25|stage6.booleanity.opening.InstructionRa_26|stage6.booleanity.opening.InstructionRa_27|stage6.booleanity.opening.InstructionRa_28|stage6.booleanity.opening.InstructionRa_29|stage6.booleanity.opening.InstructionRa_30|stage6.booleanity.opening.InstructionRa_31|stage6.booleanity.opening.BytecodeRa_0|stage6.booleanity.opening.BytecodeRa_1|stage6.booleanity.opening.BytecodeRa_2|stage6.booleanity.opening.RamRa_0|stage6.booleanity.opening.RamRa_1|stage6.booleanity.opening.RamRa_2|stage6.booleanity.opening.RamRa_3|stage6.hamming_booleanity.opening.HammingWeight|stage6.ram_ra_virtual.opening.RamRa_0|stage6.ram_ra_virtual.opening.RamRa_1|stage6.ram_ra_virtual.opening.RamRa_2|stage6.ram_ra_virtual.opening.RamRa_3|stage6.instruction_ra_virtual.opening.InstructionRa_0|stage6.instruction_ra_virtual.opening.InstructionRa_1|stage6.instruction_ra_virtual.opening.InstructionRa_2|stage6.instruction_ra_virtual.opening.InstructionRa_3|stage6.instruction_ra_virtual.opening.InstructionRa_4|stage6.instruction_ra_virtual.opening.InstructionRa_5|stage6.instruction_ra_virtual.opening.InstructionRa_6|stage6.instruction_ra_virtual.opening.InstructionRa_7|stage6.instruction_ra_virtual.opening.InstructionRa_8|stage6.instruction_ra_virtual.opening.InstructionRa_9|stage6.instruction_ra_virtual.opening.InstructionRa_10|stage6.instruction_ra_virtual.opening.InstructionRa_11|stage6.instruction_ra_virtual.opening.InstructionRa_12|stage6.instruction_ra_virtual.opening.InstructionRa_13|stage6.instruction_ra_virtual.opening.InstructionRa_14|stage6.instruction_ra_virtual.opening.InstructionRa_15|stage6.instruction_ra_virtual.opening.InstructionRa_16|stage6.instruction_ra_virtual.opening.InstructionRa_17|stage6.instruction_ra_virtual.opening.InstructionRa_18|stage6.instruction_ra_virtual.opening.InstructionRa_19|stage6.instruction_ra_virtual.opening.InstructionRa_20|stage6.instruction_ra_virtual.opening.InstructionRa_21|stage6.instruction_ra_virtual.opening.InstructionRa_22|stage6.instruction_ra_virtual.opening.InstructionRa_23|stage6.instruction_ra_virtual.opening.InstructionRa_24|stage6.instruction_ra_virtual.opening.InstructionRa_25|stage6.instruction_ra_virtual.opening.InstructionRa_26|stage6.instruction_ra_virtual.opening.InstructionRa_27|stage6.instruction_ra_virtual.opening.InstructionRa_28|stage6.instruction_ra_virtual.opening.InstructionRa_29|stage6.instruction_ra_virtual.opening.InstructionRa_30|stage6.instruction_ra_virtual.opening.InstructionRa_31|stage6.inc_claim_reduction.opening.RamInc|stage6.inc_claim_reduction.opening.RdInc" },
+    Stage6OpeningBatchPlan { symbol: "stage6.openings", stage: "stage6", proof_slot: "stage6.openings", policy: "jolt_stage6_output_order", count: 81, ordered_claims: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"], claim_operands: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"] },
+];
+#[rustfmt::skip]
+const STAGE6_INDEXED_EVAL_FAMILY_0_NAMES: &[&str] = &["stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"];
+pub const STAGE6_INDEXED_EVAL_FAMILIES: &[bolt_verifier_runtime::NamedEvalFamilyPlan] = &[
+    bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage6.bytecode_read_raf.eval.BytecodeRa", evals: STAGE6_INDEXED_EVAL_FAMILY_0_NAMES },
+];
+
+
+const STAGE6_BYTECODE_STAGE1_TERMS: &[Stage67BytecodeTermPlan] = &[
+    Stage67BytecodeTermPlan::Address { gamma_power: 0 },
+    Stage67BytecodeTermPlan::Imm { gamma_power: 1 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 0, gamma_power: 2 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 1, gamma_power: 3 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 2, gamma_power: 4 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 3, gamma_power: 5 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 4, gamma_power: 6 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 7 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 8 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 9 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 8, gamma_power: 10 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 9, gamma_power: 11 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 10, gamma_power: 12 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 11, gamma_power: 13 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 14 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 13, gamma_power: 15 },
+];
+const STAGE6_BYTECODE_STAGE2_TERMS: &[Stage67BytecodeTermPlan] = &[
+    Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 0 },
+    Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsBranch, expected: true, gamma_power: 1 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 2 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 3 },
+];
+const STAGE6_BYTECODE_STAGE3_TERMS: &[Stage67BytecodeTermPlan] = &[
+    Stage67BytecodeTermPlan::Imm { gamma_power: 0 },
+    Stage67BytecodeTermPlan::Address { gamma_power: 1 },
+    Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsRs1, expected: true, gamma_power: 2 },
+    Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsPc, expected: true, gamma_power: 3 },
+    Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsRs2, expected: true, gamma_power: 4 },
+    Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsImm, expected: true, gamma_power: 5 },
+    Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsNoop, expected: true, gamma_power: 6 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 7 },
+    Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 8 },
+];
+const STAGE6_BYTECODE_STAGE4_TERMS: &[Stage67BytecodeTermPlan] = &[
+    Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 },
+    Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs1, gamma_power: 1 },
+    Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs2, gamma_power: 2 },
+];
+const STAGE6_BYTECODE_STAGE5_TERMS: &[Stage67BytecodeTermPlan] = &[
+    Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 },
+    Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsInterleaved, expected: false, gamma_power: 1 },
+    Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 },
+];
+const STAGE6_BYTECODE_STAGES: &[Stage67BytecodeStagePlan] = &[
+    Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage1_gamma", cycle_point: "stage6.input.stage1.Imm", register_point: None, terms: STAGE6_BYTECODE_STAGE1_TERMS },
+    Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage2_gamma", cycle_point: "stage6.input.stage2.OpFlagJump", register_point: None, terms: STAGE6_BYTECODE_STAGE2_TERMS },
+    Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage3_gamma", cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", register_point: None, terms: STAGE6_BYTECODE_STAGE3_TERMS },
+    Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage4_gamma", cycle_point: "stage6.input.stage4.Rs1Ra", register_point: Some("stage6.input.stage4.Rs1Ra"), terms: STAGE6_BYTECODE_STAGE4_TERMS },
+    Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage5_gamma", cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), terms: STAGE6_BYTECODE_STAGE5_TERMS },
+];
+
+const STAGE6_BYTECODE_OUTPUT_TERMS: &[Stage67BytecodeOutputTermPlan] = &[
+    Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage1", stage_index: 0, gamma_power: 0, identity_gamma_power: Some(5) },
+    Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage2", stage_index: 1, gamma_power: 1, identity_gamma_power: None },
+    Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage3", stage_index: 2, gamma_power: 2, identity_gamma_power: Some(4) },
+    Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage4", stage_index: 3, gamma_power: 3, identity_gamma_power: None },
+    Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage5", stage_index: 4, gamma_power: 4, identity_gamma_power: None },
+    Stage67BytecodeOutputTermPlan::Entry { symbol: "stage6.bytecode_read_raf.output.term.Entry", gamma_power: 7 },
+];
+
+pub const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan {
+    point: "stage6.bytecode_read_raf.point",
+    gamma: "stage6.bytecode_read_raf.gamma",
+    bytecode_ra_evals: &STAGE6_INDEXED_EVAL_FAMILIES[0],
+    entries: "stage6.bytecode_read_raf.entries",
+    entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index",
+    stages: STAGE6_BYTECODE_STAGES,
+    output_terms: STAGE6_BYTECODE_OUTPUT_TERMS,
+    output_contribution: "stage6.bytecode_read_raf.output.contribution",
+    registers: Stage67BytecodeRegisterSymbols {
+        rd: "stage6.bytecode.entry.rd",
+        rs1: "stage6.bytecode.entry.rs1",
+        rs2: "stage6.bytecode.entry.rs2",
+    },
+    entry_lookup_table: "stage6.bytecode.entry.lookup_table",
+};
+pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.term.Stage1", "stage6.bytecode_read_raf.output.term.Stage2", "stage6.bytecode_read_raf.output.term.Stage3", "stage6.bytecode_read_raf.output.term.Stage4", "stage6.bytecode_read_raf.output.term.Stage5", "stage6.bytecode_read_raf.output.term.Entry"];
+pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[
+    Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, local_scalars: &[], expected_output: "stage6.booleanity.output.claim_expr" },
+    Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" },
+    Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" },
+    Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" },
+    Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" },
+    Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" },
 ];
-pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan {
-    role: "verifier",
-    params: STAGE6_PARAMS,
-    steps: STAGE6_PROGRAM_STEPS,
-    transcript_squeezes: STAGE6_TRANSCRIPT_SQUEEZES,
-    transcript_absorb_bytes: STAGE6_TRANSCRIPT_ABSORB_BYTES,
-    opening_inputs: STAGE6_OPENING_INPUTS,
-    field_constants: STAGE6_FIELD_CONSTANTS,
-    field_exprs: STAGE6_FIELD_EXPRS,
-    kernels: STAGE6_KERNELS,
-    claims: STAGE6_SUMCHECK_CLAIMS,
-    batches: STAGE6_SUMCHECK_BATCHES,
-    drivers: STAGE6_SUMCHECK_DRIVERS,
-    instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,
-    evals: STAGE6_SUMCHECK_EVALS,
-    point_zeros: STAGE6_POINT_ZEROS,
-    point_slices: STAGE6_POINT_SLICES,
-    point_concats: STAGE6_POINT_CONCATS,
-    opening_claims: STAGE6_OPENING_CLAIMS,
-    opening_equalities: STAGE6_OPENING_EQUALITIES,
-    opening_batches: STAGE6_OPENING_BATCHES,
+
+pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6VerifierProgramPlan {
+    base: Stage6CpuProgramPlan {
+        role: "verifier",
+        params: STAGE6_PARAMS,
+        steps: STAGE6_PROGRAM_STEPS,
+        transcript_squeezes: STAGE6_TRANSCRIPT_SQUEEZES,
+        transcript_absorb_bytes: STAGE6_TRANSCRIPT_ABSORB_BYTES,
+        opening_inputs: STAGE6_OPENING_INPUTS,
+        field_constants: STAGE6_FIELD_CONSTANTS,
+        field_exprs: STAGE6_FIELD_EXPRS,
+        scalar_exprs: STAGE6_SCALAR_EXPRS,
+        kernels: STAGE6_KERNELS,
+        claims: STAGE6_SUMCHECK_CLAIMS,
+        batches: STAGE6_SUMCHECK_BATCHES,
+        drivers: STAGE6_SUMCHECK_DRIVERS,
+        instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,
+        evals: STAGE6_SUMCHECK_EVALS,
+        indexed_eval_families: STAGE6_INDEXED_EVAL_FAMILIES,
+        relation_outputs: STAGE6_RELATION_OUTPUTS,
+        point_exprs: STAGE6_POINT_EXPRS,
+        opening_claims: STAGE6_OPENING_CLAIMS,
+        opening_equalities: STAGE6_OPENING_EQUALITIES,
+        opening_batches: STAGE6_OPENING_BATCHES,
+    },
+    bytecode_plan: STAGE6_BYTECODE_PLAN,
 };
 
 pub fn verify_stage6<T>(
@@ -647,20 +733,19 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
-    store.seed_point_zeros(program.point_zeros);
     let mut artifacts = Stage6ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage6ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage6Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage6_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "transcript_absorb_bytes" => {
+            Stage6ProgramStepKind::TranscriptAbsorbBytes => {
                 let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or(
                     VerifyStage6Error::MissingValue {
                         symbol: step.symbol,
@@ -668,7 +753,7 @@ where
                 )?;
                 absorb_stage6_bytes(absorb, transcript);
             }
-            "sumcheck_driver" => {
+            Stage6ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage6Error::MissingProof {
                         driver: step.symbol,
@@ -683,12 +768,6 @@ where
                     &mut artifacts,
                 )?;
             }
-            _ => {
-                return Err(VerifyStage6Error::InvalidProof {
-                    driver: step.symbol,
-                    reason: "unsupported stage6 program step",
-                });
-            }
         }
     }
     artifacts
@@ -704,7 +783,7 @@ pub fn stage6_verifier_program() -> &'static Stage6VerifierProgramPlan {
 fn verify_stage6_squeeze<T>(
     program: &'static Stage6VerifierProgramPlan,
     squeeze: &'static Stage6TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage6ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage6Error>
@@ -724,7 +803,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage6Error::from)?;
     artifacts.challenge_vectors.push(Stage6ChallengeVector {
         symbol: squeeze.symbol,
@@ -749,7 +828,7 @@ fn verify_stage6_driver<T>(
     driver: &'static Stage6SumcheckDriverPlan,
     proof: &Stage6Proof<Fr>,
     verifier_data: Option<&Stage6VerifierData>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage6ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage6Error>
@@ -762,12 +841,17 @@ where
         .ok_or(VerifyStage6Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage6Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage6.batched" => {
+        Stage6RelationKind::Stage6Batched => {
             verify_batched_stage6(program, driver, proof, verifier_data, store, transcript)?
         }
-        _ => return Err(VerifyStage6Error::UnsupportedRelation { relation }),
+        relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -778,32 +862,49 @@ fn verify_batched_stage6<T>(
     driver: &'static Stage6SumcheckDriverPlan,
     proof: &Stage6SumcheckOutput<Fr>,
     verifier_data: Option<&Stage6VerifierData>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage6SumcheckOutput<Fr>, VerifyStage6Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage6Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(
-                program,
+            bolt_verifier_runtime::evaluate_relation_output_batch(
                 driver,
-                verifier_data,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                program.indexed_eval_families,
                 store,
                 evals,
                 point,
                 batching_coeffs,
+                |instance, relation_output, local_point| {
+                    stage6_relation_output_inputs(program, verifier_data, store, instance, relation_output, local_point)
+                },
             )
         },
         |store, verified| observe_stage6_sumcheck_output(program, store, verified),
@@ -813,7 +914,7 @@ where
 
 fn observe_stage6_sumcheck_output<F: Field>(
     program: &'static Stage6VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage6SumcheckOutput<F>,
 ) -> Result<(), VerifyStage6Error> {
     store.observe_sumcheck_output(
@@ -822,16 +923,16 @@ fn observe_stage6_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?,
-                "stage6_booleanity" => {}
-                "instruction_read_raf" => point = normalize_instruction_read_raf_point(&point, "stage6.instruction_read_raf.point")?,
-                _ => {
-                    return Err(VerifyStage6Error::InvalidProof {
-                        driver: output.driver,
-                        reason: "unsupported point order",
-                    });
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
+                    if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf {
+                        return Err(VerifyStage6Error::InvalidProof {
+                            driver: output.driver,
+                            reason: "unsupported relation-local point order",
+                        });
+                    }
+                    point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?;
                 }
             }
             Ok(point)
@@ -843,9 +944,9 @@ fn observe_stage6_sumcheck_output<F: Field>(
         },
         |symbol| VerifyStage6Error::MissingValue { symbol },
     )?;
+    store.evaluate_named_eval_families(program.indexed_eval_families)?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage6Error::InvalidInputLength {
             input,
             expected,
@@ -853,7 +954,7 @@ fn observe_stage6_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage6Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -862,127 +963,38 @@ fn observe_stage6_sumcheck_output<F: Field>(
     )
 }
 
-fn expected_batched_output_claim(
+fn stage6_relation_output_inputs<'a>(
     program: &'static Stage6VerifierProgramPlan,
-    driver: &'static Stage6SumcheckDriverPlan,
     verifier_data: Option<&Stage6VerifierData>,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage6Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage6Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let relation = claim.relation.unwrap_or("<missing>");
-        let value = match relation {
-            "jolt.stage6.bytecode_read_raf" => {
-                let data = verifier_data
-                    .and_then(|data| data.bytecode_read_raf.as_ref())
-                    .ok_or(VerifyStage6Error::MissingValue {
-                        symbol: "stage6.bytecode_read_raf.data",
-                })?;
-                expected_bytecode_read_raf(program, data, store, evals, local_point)?
-            }
-            "jolt.stage6.booleanity" => {
-                expected_booleanity(program, store, evals, local_point)?
-            }
-            "jolt.stage6.hamming_booleanity" => {
-                expected_hamming_booleanity(store, evals, local_point)?
-            }
-            "jolt.stage6.ram_ra_virtual" => {
-                expected_ram_ra_virtual(store, evals, local_point)?
-            }
-            "jolt.stage6.instruction_ra_virtual" => {
-                expected_instruction_ra_virtual(program, store, evals, local_point)?
-            }
-            "jolt.stage6.inc_claim_reduction" => {
-                expected_inc_claim_reduction(store, evals, local_point)?
-            }
-            _ => return Err(VerifyStage6Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
+    store: &bolt_verifier_runtime::ValueStore<Fr>,
+    instance: &Stage6SumcheckInstanceResultPlan,
+    relation_output: &Stage6RelationOutputPlan,
+    local_point: &'a [Fr],
+) -> Result<bolt_verifier_runtime::RelationOutputInputs<'a, Fr>, VerifyStage6Error> {
+    if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf {
+        return Ok(bolt_verifier_runtime::RelationOutputInputs::empty());
     }
-    Ok(expected)
-}
-
-fn expected_bytecode_read_raf(
-    program: &'static Stage6VerifierProgramPlan,
-    data: &Stage6BytecodeReadRafData,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    let log_t = stage6_trace_rounds(program)?;
-    Ok(expected_stage67_bytecode_read_raf(
-        &data.entries,
-        data.entry_bytecode_index,
-        data.num_lookup_tables,
-        store,
-        evals,
-        local_point,
-        log_t,
-        &STAGE6_BYTECODE_SYMBOLS,
-    )?)
-}
-
-fn expected_booleanity(
-    program: &'static Stage6VerifierProgramPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    let log_t = stage6_trace_rounds(program)?;
-    Ok(expected_stage67_booleanity(store, evals, local_point, log_t, &STAGE6_RELATION_SYMBOLS)?)
-}
-
-fn expected_hamming_booleanity(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    Ok(expected_stage67_hamming_booleanity(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?)
-}
-
-fn expected_ram_ra_virtual(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    Ok(expected_stage67_ram_ra_virtual(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?)
-}
 
-fn expected_instruction_ra_virtual(
-    program: &'static Stage6VerifierProgramPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    Ok(expected_stage67_instruction_ra_virtual(program.opening_inputs, store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?)
-}
-
-fn expected_inc_claim_reduction(
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage6NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage6Error> {
-    Ok(expected_stage67_inc_claim_reduction(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?)
+    let data = verifier_data
+        .and_then(|data| data.bytecode_read_raf.as_ref())
+        .ok_or(VerifyStage6Error::MissingValue {
+            symbol: "stage6.bytecode_read_raf.data",
+    })?;
+    Ok(bolt_verifier_runtime::RelationOutputInputs {
+        scalars: bolt_verifier_runtime::select_named_scalars(
+            relation_output.local_scalars,
+            evaluate_stage67_bytecode_read_raf_output_scalars(
+                &program.bytecode_plan,
+                &data.entries,
+                data.entry_bytecode_index,
+                data.num_lookup_tables,
+                store,
+                local_point,
+                stage6_trace_rounds(program)?,
+            )?,
+        )?,
+        points: Vec::new(),
+    })
 }
 
 fn stage6_trace_rounds(
diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs
index 0f643fe509..c22bec670c 100644
--- a/crates/jolt-verifier/src/stages/stage7.rs
+++ b/crates/jolt-verifier/src/stages/stage7.rs
@@ -1,31 +1,40 @@
 #![allow(dead_code)]
 
-use super::common::{batch_claims, eval_by_name, find_batch, find_plan, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, reverse_slice};
-use jolt_field::{Field, Fr, RingCore};
-use jolt_poly::EqPolynomial;
+use bolt_verifier_runtime::find_plan;
+use jolt_field::{Field, Fr};
 use jolt_sumcheck::SumcheckError;
 use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};
 
-pub type Stage7NamedEval<F> = super::common::StageNamedEval<F>;
-pub type Stage7SumcheckOutput<F> = super::common::StageSumcheckOutput<F>;
-pub type Stage7ChallengeVector<F> = super::common::StageChallengeVector<F>;
-pub type Stage7ExecutionArtifacts<F> = super::common::StageExecutionArtifacts<F>;
-pub type Stage7Proof<F> = super::common::StageProof<F>;
-pub type Stage7OpeningInputValue<F> = super::common::StageOpeningInputValue<F>;
-
-pub use super::common::{
-    FieldConstantPlan as Stage7FieldConstantPlan, FieldExprPlan as Stage7FieldExprPlan,
+pub type Stage7NamedEval<F> = bolt_verifier_runtime::StageNamedEval<F>;
+pub type Stage7SumcheckOutput<F> = bolt_verifier_runtime::StageSumcheckOutput<F>;
+pub type Stage7ChallengeVector<F> = bolt_verifier_runtime::StageChallengeVector<F>;
+pub type Stage7ExecutionArtifacts<F> = bolt_verifier_runtime::StageExecutionArtifacts<F>;
+pub type Stage7Proof<F> = bolt_verifier_runtime::StageProof<F>;
+pub type Stage7OpeningInputValue<F> = bolt_verifier_runtime::StageOpeningInputValue<F>;
+pub type Stage7CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan<Stage7RelationKind>;
+pub type Stage7SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan<Stage7RelationKind>;
+pub type Stage7SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan<Stage7RelationKind>;
+pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan<Stage7RelationKind>;
+pub type Stage7RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan<Stage7RelationKind>;
+
+pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind;
+pub use bolt_verifier_runtime::{
+    ClaimKind as Stage7ClaimKind, FieldConstantPlan as Stage7FieldConstantPlan,
+    FieldExprKind as Stage7FieldExprKind,
+    FieldExprPlan as Stage7FieldExprPlan,
+    ScalarExprKind as Stage7ScalarExprKind,
+    ScalarExprPlan as Stage7ScalarExprPlan,
     KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan,
     OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan,
     OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan,
-    PointConcatPlan as Stage7PointConcatPlan, PointSlicePlan as Stage7PointSlicePlan,
-    PointZeroPlan as Stage7PointZeroPlan, ProgramStepPlan as Stage7ProgramStepPlan,
-    StageParams as Stage7Params, StageProgramPlan as Stage7CpuProgramPlan,
+    OpeningEqualityMode as Stage7OpeningEqualityMode, PointExprKind as Stage7PointExprKind,
+    PointExprPlan as Stage7PointExprPlan, ProgramStepKind as Stage7ProgramStepKind,
+    ProgramStepPlan as Stage7ProgramStepPlan,
+    StageParams as Stage7Params,
     SumcheckBatchPlan as Stage7SumcheckBatchPlan,
-    SumcheckClaimPlan as Stage7SumcheckClaimPlan, SumcheckDriverPlan as Stage7SumcheckDriverPlan,
     SumcheckEvalPlan as Stage7SumcheckEvalPlan,
-    SumcheckInstanceResultPlan as Stage7SumcheckInstanceResultPlan,
     TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan,
+    TranscriptSqueezeKind as Stage7TranscriptSqueezeKind,
     TranscriptSqueezePlan as Stage7TranscriptSqueezePlan,
 };
 
@@ -41,25 +50,20 @@ pub enum VerifyStage7Error {
     MissingValue { symbol: &'static str },
     InvalidInputLength { input: &'static str, expected: usize, actual: usize },
     InvalidProof { driver: &'static str, reason: &'static str },
-    UnsupportedFieldExpr { symbol: &'static str, formula: &'static str },
-    UnsupportedRelation { relation: &'static str },
+    UnsupportedRelation { relation: Stage7RelationKind },
     Sumcheck { driver: &'static str, error: SumcheckError<Fr> },
 }
 
-super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error);
+bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error);
 
-pub const STAGE7_PARAMS: Stage7Params = Stage7Params {
-    field: "bn254_fr",
-    pcs: "dory",
-    transcript: "blake2b_transcript",
-};
+pub const STAGE7_PARAMS: Stage7Params = Stage7Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 pub const STAGE7_PROGRAM_STEPS: &[Stage7ProgramStepPlan] = &[
-    Stage7ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage7.hamming_weight_claim_reduction.gamma" },
-    Stage7ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage7.sumcheck" },
+    Stage7ProgramStepPlan { kind: Stage7ProgramStepKind::TranscriptSqueeze, symbol: "stage7.hamming_weight_claim_reduction.gamma" },
+    Stage7ProgramStepPlan { kind: Stage7ProgramStepKind::SumcheckDriver, symbol: "stage7.sumcheck" },
 ];
 
 pub const STAGE7_TRANSCRIPT_SQUEEZES: &[Stage7TranscriptSqueezePlan] = &[
-    Stage7TranscriptSqueezePlan { symbol: "stage7.hamming_weight_claim_reduction.gamma", label: "hamming_weight_claim_reduction_gamma", kind: "challenge_scalar", count: 1 },
+    Stage7TranscriptSqueezePlan { symbol: "stage7.hamming_weight_claim_reduction.gamma", label: "hamming_weight_claim_reduction_gamma", kind: Stage7TranscriptSqueezeKind::ChallengeScalar, count: 1 },
 ];
 
 pub const STAGE7_TRANSCRIPT_ABSORB_BYTES: &[Stage7TranscriptAbsorbBytesPlan] = &[
@@ -67,240 +71,200 @@ pub const STAGE7_TRANSCRIPT_ABSORB_BYTES: &[Stage7TranscriptAbsorbBytesPlan] = &
 ];
 
 pub const STAGE7_OPENING_INPUTS: &[Stage7OpeningInputPlan] = &[
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.hamming_booleanity.HammingWeight", source_stage: "stage6", source_claim: "stage6.hamming_booleanity.opening.HammingWeight", oracle: "HammingWeight", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_3", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_4", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_5", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_6", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_7", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_8", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_9", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_10", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_11", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_12", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_13", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_14", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_15", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_16", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_17", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_18", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_19", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_20", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_21", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_22", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_23", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_24", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_25", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_26", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_27", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_28", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_29", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_30", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_31", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_0", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_1", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_2", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_3", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_3", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.hamming_booleanity.HammingWeight", source_stage: "stage6", source_claim: "stage6.hamming_booleanity.opening.HammingWeight", oracle: "HammingWeight", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage7ClaimKind::Virtual },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_3", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_4", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_5", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_6", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_7", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_8", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_9", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_10", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_11", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_12", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_13", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_14", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_15", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_16", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_17", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_18", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_19", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_20", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_21", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_22", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_23", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_24", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_25", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_26", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_27", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_28", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_29", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_30", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_31", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_0", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_1", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_2", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_3", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
+    Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_3", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed },
 ];
 
 pub const STAGE7_FIELD_CONSTANTS: &[Stage7FieldConstantPlan] = &[
     Stage7FieldConstantPlan { symbol: "stage7.field.one", field: "bn254_fr", value: 1 },
 ];
 
-macro_rules! stage7_field_expr {
-    ($symbol:literal, $formula:literal, $operands:literal) => {
-        Stage7FieldExprPlan { symbol: $symbol, kind: "op", formula: $formula, operands: $operands }
-    };
+const fn stage7_field_expr(symbol: &'static str, kind: Stage7FieldExprKind, operands: &'static [&'static str]) -> Stage7FieldExprPlan {
+    Stage7FieldExprPlan { symbol, kind, operands }
 }
 
 #[rustfmt::skip]
 pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", "field.pow:1", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", "field.pow:2", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", "field.pow:3", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", "field.pow:4", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_1"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", "field.pow:5", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", "field.pow:6", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", "field.pow:7", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", "field.pow:8", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", "field.pow:9", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", "field.pow:10", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", "field.pow:11", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", "field.pow:12", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow|stage7.field.one"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", "field.pow:13", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_4"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", "field.pow:14", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", "field.pow:15", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", "field.pow:16", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_5"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", "field.pow:17", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", "field.pow:18", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", "field.pow:19", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_6"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", "field.pow:20", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", "field.pow:21", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", "field.pow:22", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_7"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", "field.pow:23", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", "field.pow:24", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow|stage7.field.one"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", "field.pow:25", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_8"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", "field.pow:26", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", "field.pow:27", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", "field.pow:28", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_9"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", "field.pow:29", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", "field.pow:30", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", "field.pow:31", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_10"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", "field.pow:32", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", "field.pow:33", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", "field.pow:34", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_11"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", "field.pow:35", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", "field.pow:36", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow|stage7.field.one"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", "field.pow:37", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_12"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", "field.pow:38", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", "field.pow:39", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", "field.pow:40", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_13"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", "field.pow:41", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", "field.pow:42", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", "field.pow:43", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_14"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", "field.pow:44", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", "field.pow:45", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", "field.pow:46", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_15"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", "field.pow:47", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", "field.pow:48", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow|stage7.field.one"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", "field.pow:49", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_16"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", "field.pow:50", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", "field.pow:51", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", "field.pow:52", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_17"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", "field.pow:53", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", "field.pow:54", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", "field.pow:55", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_18"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", "field.pow:56", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", "field.pow:57", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", "field.pow:58", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_19"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", "field.pow:59", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", "field.pow:60", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow|stage7.field.one"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", "field.pow:61", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_20"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", "field.pow:62", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", "field.pow:63", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", "field.pow:64", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_21"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", "field.pow:65", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", "field.pow:66", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", "field.pow:67", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_22"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", "field.pow:68", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", "field.pow:69", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", "field.pow:70", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_23"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", "field.pow:71", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", "field.pow:72", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow|stage7.field.one"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", "field.pow:73", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_24"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", "field.pow:74", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", "field.pow:75", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", "field.pow:76", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_25"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", "field.pow:77", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", "field.pow:78", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", "field.pow:79", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_26"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", "field.pow:80", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", "field.pow:81", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", "field.pow:82", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_27"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", "field.pow:83", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", "field.pow:84", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow|stage7.field.one"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", "field.pow:85", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_28"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", "field.pow:86", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", "field.pow:87", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", "field.pow:88", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_29"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", "field.pow:89", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", "field.pow:90", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", "field.pow:91", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_30"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", "field.pow:92", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", "field.pow:93", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", "field.pow:94", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_31"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", "field.pow:95", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", "field.pow:96", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow|stage7.field.one"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", "field.pow:97", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", "field.pow:98", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", "field.pow:99", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", "field.pow:100", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_1"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", "field.pow:101", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", "field.pow:102", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", "field.pow:103", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", "field.pow:104", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", "field.pow:105", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", "field.pow:106", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", "field.pow:107", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", "field.pow:108", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", "field.pow:109", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", "field.pow:110", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", "field.pow:111", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", "field.pow:112", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_2"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", "field.pow:113", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", "field.pow:114", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", "field.pow:115", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", "field.pow:116", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_3"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial0", "field.add", "stage7.field.one|stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial1", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial0|stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial2", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial1|stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial3", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial2|stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial4", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial3|stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial5", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial4|stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial6", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial5|stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial7", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial6|stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial8", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial7|stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial9", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial8|stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial10", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial9|stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial11", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial10|stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial12", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial11|stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial13", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial12|stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial14", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial13|stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial15", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial14|stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial16", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial15|stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial17", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial16|stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial18", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial17|stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial19", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial18|stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial20", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial19|stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial21", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial20|stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial22", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial21|stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial23", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial22|stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial24", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial23|stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial25", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial24|stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial26", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial25|stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial27", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial26|stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial28", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial27|stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial29", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial28|stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial30", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial29|stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial31", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial30|stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial32", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial31|stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial33", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial32|stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial34", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial33|stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial35", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial34|stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial36", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial35|stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial37", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial36|stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial38", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial37|stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial39", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial38|stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial40", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial39|stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial41", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial40|stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial42", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial41|stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial43", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial42|stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial44", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial43|stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial45", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial44|stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial46", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial45|stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial47", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial46|stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial48", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial47|stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial49", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial48|stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial50", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial49|stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial51", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial50|stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial52", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial51|stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial53", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial52|stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial54", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial53|stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial55", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial54|stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial56", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial55|stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial57", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial56|stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial58", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial57|stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial59", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial58|stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial60", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial59|stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial61", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial60|stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial62", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial61|stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial63", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial62|stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial64", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial63|stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial65", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial64|stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial66", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial65|stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial67", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial66|stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial68", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial67|stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial69", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial68|stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial70", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial69|stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial71", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial70|stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial72", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial71|stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial73", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial72|stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial74", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial73|stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial75", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial74|stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial76", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial75|stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial77", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial76|stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial78", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial77|stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial79", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial78|stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial80", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial79|stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial81", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial80|stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial82", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial81|stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial83", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial82|stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial84", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial83|stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial85", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial84|stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial86", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial85|stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial87", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial86|stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial88", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial87|stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial89", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial88|stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial90", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial89|stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial91", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial90|stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial92", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial91|stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial93", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial92|stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial94", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial93|stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial95", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial94|stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial96", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial95|stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial97", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial96|stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial98", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial97|stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial99", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial98|stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial100", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial99|stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial101", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial100|stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial102", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial101|stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial103", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial102|stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial104", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial103|stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial105", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial104|stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial106", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial105|stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial107", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial106|stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial108", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial107|stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial109", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial108|stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial110", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial109|stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial111", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial110|stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"),
-    stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial112", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial111|stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial113", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial112|stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial114", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial113|stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial115", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial114|stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"),
+
+];
+const fn stage7_scalar_expr(symbol: &'static str, kind: Stage7ScalarExprKind, operands: &'static [&'static str]) -> Stage7ScalarExprPlan {
+    Stage7ScalarExprPlan { symbol, kind, operands }
+}
+
+#[rustfmt::skip]
+pub const STAGE7_SCALAR_EXPRS: &[Stage7ScalarExprPlan] = &[
+    stage7_scalar_expr("stage7.hamming_weight_claim_reduction.input.claim_expr", Stage7ScalarExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[], shared_term_offsets: &[], row_term_offsets: &[0, 1, 2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7ScalarExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.Booleanity", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.booleanity.InstructionRa_0"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"]),
+    stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"]),
+    stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"]),
+    stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"]),
+    stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_0"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_1"]),
+    stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_2"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]),
 ];
 pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[
 
 ];
 
 pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[
-    Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some("jolt.stage7.hamming_weight_claim_reduction"), claim_value: "stage7.hamming_weight_claim_reduction.claim_expr.partial115", input_openings: "stage7.input.stage6.hamming_booleanity.HammingWeight|stage7.input.stage6.booleanity.InstructionRa_0|stage7.input.stage6.instruction_ra_virtual.InstructionRa_0|stage7.input.stage6.booleanity.InstructionRa_1|stage7.input.stage6.instruction_ra_virtual.InstructionRa_1|stage7.input.stage6.booleanity.InstructionRa_2|stage7.input.stage6.instruction_ra_virtual.InstructionRa_2|stage7.input.stage6.booleanity.InstructionRa_3|stage7.input.stage6.instruction_ra_virtual.InstructionRa_3|stage7.input.stage6.booleanity.InstructionRa_4|stage7.input.stage6.instruction_ra_virtual.InstructionRa_4|stage7.input.stage6.booleanity.InstructionRa_5|stage7.input.stage6.instruction_ra_virtual.InstructionRa_5|stage7.input.stage6.booleanity.InstructionRa_6|stage7.input.stage6.instruction_ra_virtual.InstructionRa_6|stage7.input.stage6.booleanity.InstructionRa_7|stage7.input.stage6.instruction_ra_virtual.InstructionRa_7|stage7.input.stage6.booleanity.InstructionRa_8|stage7.input.stage6.instruction_ra_virtual.InstructionRa_8|stage7.input.stage6.booleanity.InstructionRa_9|stage7.input.stage6.instruction_ra_virtual.InstructionRa_9|stage7.input.stage6.booleanity.InstructionRa_10|stage7.input.stage6.instruction_ra_virtual.InstructionRa_10|stage7.input.stage6.booleanity.InstructionRa_11|stage7.input.stage6.instruction_ra_virtual.InstructionRa_11|stage7.input.stage6.booleanity.InstructionRa_12|stage7.input.stage6.instruction_ra_virtual.InstructionRa_12|stage7.input.stage6.booleanity.InstructionRa_13|stage7.input.stage6.instruction_ra_virtual.InstructionRa_13|stage7.input.stage6.booleanity.InstructionRa_14|stage7.input.stage6.instruction_ra_virtual.InstructionRa_14|stage7.input.stage6.booleanity.InstructionRa_15|stage7.input.stage6.instruction_ra_virtual.InstructionRa_15|stage7.input.stage6.booleanity.InstructionRa_16|stage7.input.stage6.instruction_ra_virtual.InstructionRa_16|stage7.input.stage6.booleanity.InstructionRa_17|stage7.input.stage6.instruction_ra_virtual.InstructionRa_17|stage7.input.stage6.booleanity.InstructionRa_18|stage7.input.stage6.instruction_ra_virtual.InstructionRa_18|stage7.input.stage6.booleanity.InstructionRa_19|stage7.input.stage6.instruction_ra_virtual.InstructionRa_19|stage7.input.stage6.booleanity.InstructionRa_20|stage7.input.stage6.instruction_ra_virtual.InstructionRa_20|stage7.input.stage6.booleanity.InstructionRa_21|stage7.input.stage6.instruction_ra_virtual.InstructionRa_21|stage7.input.stage6.booleanity.InstructionRa_22|stage7.input.stage6.instruction_ra_virtual.InstructionRa_22|stage7.input.stage6.booleanity.InstructionRa_23|stage7.input.stage6.instruction_ra_virtual.InstructionRa_23|stage7.input.stage6.booleanity.InstructionRa_24|stage7.input.stage6.instruction_ra_virtual.InstructionRa_24|stage7.input.stage6.booleanity.InstructionRa_25|stage7.input.stage6.instruction_ra_virtual.InstructionRa_25|stage7.input.stage6.booleanity.InstructionRa_26|stage7.input.stage6.instruction_ra_virtual.InstructionRa_26|stage7.input.stage6.booleanity.InstructionRa_27|stage7.input.stage6.instruction_ra_virtual.InstructionRa_27|stage7.input.stage6.booleanity.InstructionRa_28|stage7.input.stage6.instruction_ra_virtual.InstructionRa_28|stage7.input.stage6.booleanity.InstructionRa_29|stage7.input.stage6.instruction_ra_virtual.InstructionRa_29|stage7.input.stage6.booleanity.InstructionRa_30|stage7.input.stage6.instruction_ra_virtual.InstructionRa_30|stage7.input.stage6.booleanity.InstructionRa_31|stage7.input.stage6.instruction_ra_virtual.InstructionRa_31|stage7.input.stage6.booleanity.BytecodeRa_0|stage7.input.stage6.bytecode_read_raf.BytecodeRa_0|stage7.input.stage6.booleanity.BytecodeRa_1|stage7.input.stage6.bytecode_read_raf.BytecodeRa_1|stage7.input.stage6.booleanity.BytecodeRa_2|stage7.input.stage6.bytecode_read_raf.BytecodeRa_2|stage7.input.stage6.booleanity.RamRa_0|stage7.input.stage6.ram_ra_virtual.RamRa_0|stage7.input.stage6.booleanity.RamRa_1|stage7.input.stage6.ram_ra_virtual.RamRa_1|stage7.input.stage6.booleanity.RamRa_2|stage7.input.stage6.ram_ra_virtual.RamRa_2|stage7.input.stage6.booleanity.RamRa_3|stage7.input.stage6.ram_ra_virtual.RamRa_3" },
-];
-pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[
-    4,
+    Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some(Stage7RelationKind::Stage7HammingWeightClaimReduction), claim_value: "stage7.hamming_weight_claim_reduction.input.claim_expr" },
 ];
+pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[4];
 
 pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[
-    Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, ordered_claims: "stage7.hamming_weight_claim_reduction.input", claim_operands: "stage7.hamming_weight_claim_reduction.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
-];
-pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[
-    4,
+    Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, claim_operands: &["stage7.hamming_weight_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE },
 ];
+pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4];
 
 pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[
-    Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: None, relation: Some("jolt.stage7.batched"), batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 },
+    Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: None, relation: Some(Stage7RelationKind::Stage7Batched), batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 },
+];
+pub const STAGE7_RELATION_OUTPUTS: &[Stage7RelationOutputPlan] = &[
+    Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.claim_expr" },
 ];
+
 pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[
-    Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: "jolt.stage7.hamming_weight_claim_reduction", index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: "reverse", degree: 2 },
+    Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 },
 ];
 
-macro_rules! stage7_sumcheck_eval {
-    ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => {
-        Stage7SumcheckEvalPlan { symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle }
-    };
+const fn stage7_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage7SumcheckEvalPlan {
+    Stage7SumcheckEvalPlan { symbol, source, name, index, oracle }
 }
 
 #[rustfmt::skip]
 pub const STAGE7_SUMCHECK_EVALS: &[Stage7SumcheckEvalPlan] = &[
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", 0, "InstructionRa_0"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", 1, "InstructionRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", 2, "InstructionRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", 3, "InstructionRa_3"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", 4, "InstructionRa_4"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", 5, "InstructionRa_5"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", 6, "InstructionRa_6"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", 7, "InstructionRa_7"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", 8, "InstructionRa_8"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", 9, "InstructionRa_9"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", 10, "InstructionRa_10"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", 11, "InstructionRa_11"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", 12, "InstructionRa_12"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", 13, "InstructionRa_13"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", 14, "InstructionRa_14"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", 15, "InstructionRa_15"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", 16, "InstructionRa_16"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", 17, "InstructionRa_17"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", 18, "InstructionRa_18"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", 19, "InstructionRa_19"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", 20, "InstructionRa_20"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", 21, "InstructionRa_21"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", 22, "InstructionRa_22"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", 23, "InstructionRa_23"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", 24, "InstructionRa_24"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", 25, "InstructionRa_25"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", 26, "InstructionRa_26"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", 27, "InstructionRa_27"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", 28, "InstructionRa_28"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", 29, "InstructionRa_29"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", 30, "InstructionRa_30"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", 31, "InstructionRa_31"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", 32, "BytecodeRa_0"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", 35, "RamRa_0"),
-    stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", 36, "RamRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", 37, "RamRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", 38, "RamRa_3"),
-];
-
-pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[
-
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", 0, "InstructionRa_0"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", 1, "InstructionRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", 2, "InstructionRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", 3, "InstructionRa_3"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", 4, "InstructionRa_4"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", 5, "InstructionRa_5"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", 6, "InstructionRa_6"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", 7, "InstructionRa_7"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", 8, "InstructionRa_8"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", 9, "InstructionRa_9"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", 10, "InstructionRa_10"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", 11, "InstructionRa_11"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", 12, "InstructionRa_12"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", 13, "InstructionRa_13"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", 14, "InstructionRa_14"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", 15, "InstructionRa_15"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", 16, "InstructionRa_16"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", 17, "InstructionRa_17"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", 18, "InstructionRa_18"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", 19, "InstructionRa_19"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", 20, "InstructionRa_20"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", 21, "InstructionRa_21"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", 22, "InstructionRa_22"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", 23, "InstructionRa_23"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", 24, "InstructionRa_24"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", 25, "InstructionRa_25"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", 26, "InstructionRa_26"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", 27, "InstructionRa_27"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", 28, "InstructionRa_28"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", 29, "InstructionRa_29"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", 30, "InstructionRa_30"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", 31, "InstructionRa_31"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", 32, "BytecodeRa_0"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", 35, "RamRa_0"),
+    stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", 36, "RamRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", 37, "RamRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", 38, "RamRa_3"),
 ];
 
-pub const STAGE7_POINT_SLICES: &[Stage7PointSlicePlan] = &[
-    Stage7PointSlicePlan { symbol: "stage7.hamming_weight_claim_reduction.point.cycle", source: "stage7.input.stage6.booleanity.InstructionRa_0", offset: 4, length: 16, input: "stage7.input.stage6.booleanity.InstructionRa_0" },
+pub const STAGE7_POINT_EXPRS: &[Stage7PointExprPlan] = &[
+    Stage7PointExprPlan { symbol: "stage7.hamming_weight_claim_reduction.point.cycle", kind: Stage7PointExprKind::Slice { offset: 4, length: 16 }, operands: &["stage7.input.stage6.booleanity.InstructionRa_0"] },
+    Stage7PointExprPlan { symbol: "stage7.hamming_weight_claim_reduction.point", kind: Stage7PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage7.hamming_weight_claim_reduction.instance", "stage7.hamming_weight_claim_reduction.point.cycle"] },
 ];
 
-pub const STAGE7_POINT_CONCATS: &[Stage7PointConcatPlan] = &[
-    Stage7PointConcatPlan { symbol: "stage7.hamming_weight_claim_reduction.point", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage7.hamming_weight_claim_reduction.instance|stage7.hamming_weight_claim_reduction.point.cycle" },
-];
 pub const STAGE7_OPENING_CLAIMS: &[Stage7OpeningClaimPlan] = &[
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_0" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_1" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_2" },
-    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_3" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_0" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_1" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_2" },
+    Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_3" },
 ];
 
 pub const STAGE7_OPENING_EQUALITIES: &[Stage7OpeningClaimEqualityPlan] = &[
@@ -308,7 +272,7 @@ pub const STAGE7_OPENING_EQUALITIES: &[Stage7OpeningClaimEqualityPlan] = &[
 ];
 
 pub const STAGE7_OPENING_BATCHES: &[Stage7OpeningBatchPlan] = &[
-    Stage7OpeningBatchPlan { symbol: "stage7.openings", stage: "stage7", proof_slot: "stage7.openings", policy: "jolt_stage7_output_order", count: 39, ordered_claims: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0|stage7.hamming_weight_claim_reduction.opening.InstructionRa_1|stage7.hamming_weight_claim_reduction.opening.InstructionRa_2|stage7.hamming_weight_claim_reduction.opening.InstructionRa_3|stage7.hamming_weight_claim_reduction.opening.InstructionRa_4|stage7.hamming_weight_claim_reduction.opening.InstructionRa_5|stage7.hamming_weight_claim_reduction.opening.InstructionRa_6|stage7.hamming_weight_claim_reduction.opening.InstructionRa_7|stage7.hamming_weight_claim_reduction.opening.InstructionRa_8|stage7.hamming_weight_claim_reduction.opening.InstructionRa_9|stage7.hamming_weight_claim_reduction.opening.InstructionRa_10|stage7.hamming_weight_claim_reduction.opening.InstructionRa_11|stage7.hamming_weight_claim_reduction.opening.InstructionRa_12|stage7.hamming_weight_claim_reduction.opening.InstructionRa_13|stage7.hamming_weight_claim_reduction.opening.InstructionRa_14|stage7.hamming_weight_claim_reduction.opening.InstructionRa_15|stage7.hamming_weight_claim_reduction.opening.InstructionRa_16|stage7.hamming_weight_claim_reduction.opening.InstructionRa_17|stage7.hamming_weight_claim_reduction.opening.InstructionRa_18|stage7.hamming_weight_claim_reduction.opening.InstructionRa_19|stage7.hamming_weight_claim_reduction.opening.InstructionRa_20|stage7.hamming_weight_claim_reduction.opening.InstructionRa_21|stage7.hamming_weight_claim_reduction.opening.InstructionRa_22|stage7.hamming_weight_claim_reduction.opening.InstructionRa_23|stage7.hamming_weight_claim_reduction.opening.InstructionRa_24|stage7.hamming_weight_claim_reduction.opening.InstructionRa_25|stage7.hamming_weight_claim_reduction.opening.InstructionRa_26|stage7.hamming_weight_claim_reduction.opening.InstructionRa_27|stage7.hamming_weight_claim_reduction.opening.InstructionRa_28|stage7.hamming_weight_claim_reduction.opening.InstructionRa_29|stage7.hamming_weight_claim_reduction.opening.InstructionRa_30|stage7.hamming_weight_claim_reduction.opening.InstructionRa_31|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2|stage7.hamming_weight_claim_reduction.opening.RamRa_0|stage7.hamming_weight_claim_reduction.opening.RamRa_1|stage7.hamming_weight_claim_reduction.opening.RamRa_2|stage7.hamming_weight_claim_reduction.opening.RamRa_3", claim_operands: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0|stage7.hamming_weight_claim_reduction.opening.InstructionRa_1|stage7.hamming_weight_claim_reduction.opening.InstructionRa_2|stage7.hamming_weight_claim_reduction.opening.InstructionRa_3|stage7.hamming_weight_claim_reduction.opening.InstructionRa_4|stage7.hamming_weight_claim_reduction.opening.InstructionRa_5|stage7.hamming_weight_claim_reduction.opening.InstructionRa_6|stage7.hamming_weight_claim_reduction.opening.InstructionRa_7|stage7.hamming_weight_claim_reduction.opening.InstructionRa_8|stage7.hamming_weight_claim_reduction.opening.InstructionRa_9|stage7.hamming_weight_claim_reduction.opening.InstructionRa_10|stage7.hamming_weight_claim_reduction.opening.InstructionRa_11|stage7.hamming_weight_claim_reduction.opening.InstructionRa_12|stage7.hamming_weight_claim_reduction.opening.InstructionRa_13|stage7.hamming_weight_claim_reduction.opening.InstructionRa_14|stage7.hamming_weight_claim_reduction.opening.InstructionRa_15|stage7.hamming_weight_claim_reduction.opening.InstructionRa_16|stage7.hamming_weight_claim_reduction.opening.InstructionRa_17|stage7.hamming_weight_claim_reduction.opening.InstructionRa_18|stage7.hamming_weight_claim_reduction.opening.InstructionRa_19|stage7.hamming_weight_claim_reduction.opening.InstructionRa_20|stage7.hamming_weight_claim_reduction.opening.InstructionRa_21|stage7.hamming_weight_claim_reduction.opening.InstructionRa_22|stage7.hamming_weight_claim_reduction.opening.InstructionRa_23|stage7.hamming_weight_claim_reduction.opening.InstructionRa_24|stage7.hamming_weight_claim_reduction.opening.InstructionRa_25|stage7.hamming_weight_claim_reduction.opening.InstructionRa_26|stage7.hamming_weight_claim_reduction.opening.InstructionRa_27|stage7.hamming_weight_claim_reduction.opening.InstructionRa_28|stage7.hamming_weight_claim_reduction.opening.InstructionRa_29|stage7.hamming_weight_claim_reduction.opening.InstructionRa_30|stage7.hamming_weight_claim_reduction.opening.InstructionRa_31|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2|stage7.hamming_weight_claim_reduction.opening.RamRa_0|stage7.hamming_weight_claim_reduction.opening.RamRa_1|stage7.hamming_weight_claim_reduction.opening.RamRa_2|stage7.hamming_weight_claim_reduction.opening.RamRa_3" },
+    Stage7OpeningBatchPlan { symbol: "stage7.openings", stage: "stage7", proof_slot: "stage7.openings", policy: "jolt_stage7_output_order", count: 39, ordered_claims: &["stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_1", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_2", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_3", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_4", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_5", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_6", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_7", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_8", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_9", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_10", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_11", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_12", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_13", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_14", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_15", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_16", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_17", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_18", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_19", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_20", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_21", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_22", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_23", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_24", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_25", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_26", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_27", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_28", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_29", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_30", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_31", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.opening.RamRa_0", "stage7.hamming_weight_claim_reduction.opening.RamRa_1", "stage7.hamming_weight_claim_reduction.opening.RamRa_2", "stage7.hamming_weight_claim_reduction.opening.RamRa_3"], claim_operands: &["stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_1", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_2", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_3", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_4", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_5", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_6", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_7", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_8", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_9", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_10", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_11", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_12", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_13", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_14", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_15", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_16", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_17", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_18", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_19", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_20", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_21", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_22", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_23", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_24", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_25", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_26", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_27", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_28", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_29", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_30", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_31", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.opening.RamRa_0", "stage7.hamming_weight_claim_reduction.opening.RamRa_1", "stage7.hamming_weight_claim_reduction.opening.RamRa_2", "stage7.hamming_weight_claim_reduction.opening.RamRa_3"] },
 ];
 pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan {
     role: "verifier",
@@ -319,15 +283,16 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan {
     opening_inputs: STAGE7_OPENING_INPUTS,
     field_constants: STAGE7_FIELD_CONSTANTS,
     field_exprs: STAGE7_FIELD_EXPRS,
+    scalar_exprs: STAGE7_SCALAR_EXPRS,
     kernels: STAGE7_KERNELS,
     claims: STAGE7_SUMCHECK_CLAIMS,
     batches: STAGE7_SUMCHECK_BATCHES,
     drivers: STAGE7_SUMCHECK_DRIVERS,
     instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS,
     evals: STAGE7_SUMCHECK_EVALS,
-    point_zeros: STAGE7_POINT_ZEROS,
-    point_slices: STAGE7_POINT_SLICES,
-    point_concats: STAGE7_POINT_CONCATS,
+    indexed_eval_families: &[],
+    relation_outputs: STAGE7_RELATION_OUTPUTS,
+    point_exprs: STAGE7_POINT_EXPRS,
     opening_claims: STAGE7_OPENING_CLAIMS,
     opening_equalities: STAGE7_OPENING_EQUALITIES,
     opening_batches: STAGE7_OPENING_BATCHES,
@@ -360,20 +325,19 @@ where
         });
     }
     let mut store =
-        super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
+        bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?;
     store.seed_constants(program.field_constants);
-    store.seed_point_zeros(program.point_zeros);
     let mut artifacts = Stage7ExecutionArtifacts::default();
     for step in program.steps {
         match step.kind {
-            "transcript_squeeze" => {
+            Stage7ProgramStepKind::TranscriptSqueeze => {
                 let squeeze =
                     find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage7Error::MissingValue {
                         symbol: step.symbol,
                     })?;
                 verify_stage7_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?;
             }
-            "transcript_absorb_bytes" => {
+            Stage7ProgramStepKind::TranscriptAbsorbBytes => {
                 let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or(
                     VerifyStage7Error::MissingValue {
                         symbol: step.symbol,
@@ -381,7 +345,7 @@ where
                 )?;
                 absorb_stage7_bytes(absorb, transcript);
             }
-            "sumcheck_driver" => {
+            Stage7ProgramStepKind::SumcheckDriver => {
                 let driver =
                     find_plan(program.drivers, step.symbol).ok_or(VerifyStage7Error::MissingProof {
                         driver: step.symbol,
@@ -395,12 +359,6 @@ where
                     &mut artifacts,
                 )?;
             }
-            _ => {
-                return Err(VerifyStage7Error::InvalidProof {
-                    driver: step.symbol,
-                    reason: "unsupported stage7 program step",
-                });
-            }
         }
     }
     artifacts
@@ -416,7 +374,7 @@ pub fn stage7_verifier_program() -> &'static Stage7VerifierProgramPlan {
 fn verify_stage7_squeeze<T>(
     program: &'static Stage7VerifierProgramPlan,
     squeeze: &'static Stage7TranscriptSqueezePlan,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage7ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage7Error>
@@ -432,7 +390,7 @@ where
         }
     })?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage7Error::from)?;
     artifacts.challenge_vectors.push(Stage7ChallengeVector {
         symbol: squeeze.symbol,
@@ -456,7 +414,7 @@ fn verify_stage7_driver<T>(
     program: &'static Stage7VerifierProgramPlan,
     driver: &'static Stage7SumcheckDriverPlan,
     proof: &Stage7Proof<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
     artifacts: &mut Stage7ExecutionArtifacts<Fr>,
 ) -> Result<(), VerifyStage7Error>
@@ -469,12 +427,17 @@ where
         .ok_or(VerifyStage7Error::MissingProof {
             driver: driver.symbol,
         })?;
-    let relation = driver.relation.unwrap_or("<missing>");
+    let Some(relation) = driver.relation else {
+        return Err(VerifyStage7Error::InvalidProof {
+            driver: driver.symbol,
+            reason: "missing driver relation",
+        });
+    };
     let output = match relation {
-        "jolt.stage7.batched" => {
+        Stage7RelationKind::Stage7Batched => {
             verify_batched_stage7(program, driver, proof, store, transcript)?
         }
-        _ => return Err(VerifyStage7Error::UnsupportedRelation { relation }),
+        relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }),
     };
     artifacts.sumchecks.push(output);
     Ok(())
@@ -484,25 +447,48 @@ fn verify_batched_stage7<T>(
     program: &'static Stage7VerifierProgramPlan,
     driver: &'static Stage7SumcheckDriverPlan,
     proof: &Stage7SumcheckOutput<Fr>,
-    store: &mut super::common::ValueStore<Fr>,
+    store: &mut bolt_verifier_runtime::ValueStore<Fr>,
     transcript: &mut T,
 ) -> Result<Stage7SumcheckOutput<Fr>, VerifyStage7Error>
 where
     T: Transcript<Challenge = Fr>,
 {
-    super::common::verify_batched_sumcheck(
+    store.evaluate_available_points(
+        program.point_exprs,
+        |input, expected, actual| VerifyStage7Error::InvalidInputLength {
+            input,
+            expected,
+            actual,
+        },
+    )?;
+    bolt_verifier_runtime::verify_batched_sumcheck(
         driver,
         proof,
         program.claims,
         program.batches,
         program.field_exprs,
+        program.scalar_exprs,
         program.opening_inputs,
         program.opening_claims,
         program.opening_batches,
         store,
         transcript,
         |store, evals, point, batching_coeffs| {
-            expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs)
+            bolt_verifier_runtime::evaluate_relation_output_batch(
+                driver,
+                program.batches,
+                program.claims,
+                program.instance_results,
+                program.relation_outputs,
+                program.field_exprs,
+                program.scalar_exprs,
+                &[],
+                store,
+                evals,
+                point,
+                batching_coeffs,
+                |_, _, _| Ok::<_, VerifyStage7Error>(bolt_verifier_runtime::RelationOutputInputs::empty()),
+            )
         },
         |store, verified| observe_stage7_sumcheck_output(program, store, verified),
         |driver, error| VerifyStage7Error::Sumcheck { driver, error },
@@ -511,7 +497,7 @@ where
 
 fn observe_stage7_sumcheck_output<F: Field>(
     program: &'static Stage7VerifierProgramPlan,
-    store: &mut super::common::ValueStore<F>,
+    store: &mut bolt_verifier_runtime::ValueStore<F>,
     output: &Stage7SumcheckOutput<F>,
 ) -> Result<(), VerifyStage7Error> {
     store.observe_sumcheck_output(
@@ -520,15 +506,12 @@ fn observe_stage7_sumcheck_output<F: Field>(
         output,
         |instance, mut point| {
             match instance.point_order {
-                "as_is" => {}
-                "reverse" => point.reverse(),
-                "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage7_trace_rounds(program)?, "stage7.bytecode_read_raf.point")?,
-                "stage7_booleanity" => {}
-                "instruction_read_raf" => point = normalize_instruction_read_raf_point(&point, "stage7.instruction_read_raf.point")?,
-                _ => {
+                bolt_verifier_runtime::SumcheckPointOrder::AsIs => {}
+                bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(),
+                bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => {
                     return Err(VerifyStage7Error::InvalidProof {
                         driver: output.driver,
-                        reason: "unsupported point order",
+                        reason: "unsupported relation-local point order",
                     });
                 }
             }
@@ -542,8 +525,7 @@ fn observe_stage7_sumcheck_output<F: Field>(
         |symbol| VerifyStage7Error::MissingValue { symbol },
     )?;
     store.evaluate_available_points(
-        program.point_slices,
-        program.point_concats,
+        program.point_exprs,
         |input, expected, actual| VerifyStage7Error::InvalidInputLength {
             input,
             expected,
@@ -551,7 +533,7 @@ fn observe_stage7_sumcheck_output<F: Field>(
         },
     )?;
     store
-        .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr)
+        .evaluate_available_exprs(program.field_exprs, program.scalar_exprs)
         .map_err(VerifyStage7Error::from)?;
     store.verify_opening_equalities(
         program.opening_equalities,
@@ -559,124 +541,3 @@ fn observe_stage7_sumcheck_output<F: Field>(
         |symbol| VerifyStage7Error::MissingValue { symbol },
     )
 }
-
-fn expected_batched_output_claim(
-    program: &'static Stage7VerifierProgramPlan,
-    driver: &'static Stage7SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage7NamedEval<Fr>],
-    point: &[Fr],
-    batching_coeffs: &[Fr],
-) -> Result<Fr, VerifyStage7Error> {
-    let batch = find_batch(program.batches, driver.symbol, driver.batch)?;
-    let claims = batch_claims(program.claims, batch)?;
-    let mut expected = Fr::from_u64(0);
-    for (claim, coefficient) in claims.iter().zip(batching_coeffs) {
-        let instance = program
-            .instance_results
-            .iter()
-            .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol)
-            .ok_or(VerifyStage7Error::MissingClaim {
-                batch: batch.symbol,
-                claim: claim.symbol,
-            })?;
-        let local_point = point
-            .get(instance.round_offset..instance.round_offset + instance.num_rounds)
-            .ok_or(VerifyStage7Error::InvalidInputLength {
-                input: instance.symbol,
-                expected: instance.round_offset + instance.num_rounds,
-                actual: point.len(),
-            })?;
-        let relation = claim.relation.unwrap_or("<missing>");
-        let value = match relation {
-            "jolt.stage7.hamming_weight_claim_reduction" => {
-                expected_hamming_weight_claim_reduction(program, driver, store, evals, local_point)?
-            }
-            _ => return Err(VerifyStage7Error::UnsupportedRelation { relation }),
-        };
-        expected += *coefficient * value;
-    }
-    Ok(expected)
-}
-
-fn expected_hamming_weight_claim_reduction(
-    program: &'static Stage7VerifierProgramPlan,
-    driver: &'static Stage7SumcheckDriverPlan,
-    store: &super::common::ValueStore<Fr>,
-    evals: &[Stage7NamedEval<Fr>],
-    local_point: &[Fr],
-) -> Result<Fr, VerifyStage7Error> {
-    let rho_rev = reverse_slice(local_point);
-    let booleanity_point = super::common::store_point(store, "stage7.input.stage6.booleanity.InstructionRa_0")?;
-    let r_addr_bool =
-        booleanity_point
-            .get(..local_point.len())
-            .ok_or(VerifyStage7Error::InvalidInputLength {
-                input: "stage7.input.stage6.booleanity.InstructionRa_0",
-                expected: local_point.len(),
-                actual: booleanity_point.len(),
-            })?;
-    let eq_bool = EqPolynomial::<Fr>::mle(&rho_rev, r_addr_bool);
-    let gamma = super::common::store_scalar(store, "stage7.hamming_weight_claim_reduction.gamma")?;
-    let mut gamma_power = Fr::from_u64(1);
-    let mut expected = Fr::from_u64(0);
-    let mut eval_plans = program
-        .evals
-        .iter()
-        .filter(|eval| eval.source == driver.symbol)
-        .collect::<Vec<_>>();
-    eval_plans.sort_by_key(|eval| eval.index);
-    for eval_plan in eval_plans {
-        let g_i = eval_by_name(evals, eval_plan.name)?;
-        let virt_point =
-            stage7_virtualization_point(store, eval_plan.oracle, local_point.len())?;
-        let eq_virt = EqPolynomial::<Fr>::mle(&rho_rev, virt_point);
-        expected += g_i * (gamma_power + gamma_power * gamma * eq_bool
-            + gamma_power * gamma.square() * eq_virt);
-        gamma_power *= gamma;
-        gamma_power *= gamma;
-        gamma_power *= gamma;
-    }
-    Ok(expected)
-}
-
-fn stage7_virtualization_point<'a>(
-    store: &'a super::common::ValueStore<Fr>,
-    oracle: &str,
-    log_k_chunk: usize,
-) -> Result<&'a [Fr], VerifyStage7Error> {
-    let symbol = if oracle.starts_with("InstructionRa_") {
-        format!("stage7.input.stage6.instruction_ra_virtual.{oracle}")
-    } else if oracle.starts_with("BytecodeRa_") {
-        format!("stage7.input.stage6.bytecode_read_raf.{oracle}")
-    } else if oracle.starts_with("RamRa_") {
-        format!("stage7.input.stage6.ram_ra_virtual.{oracle}")
-    } else {
-        return Err(VerifyStage7Error::MissingValue {
-            symbol: "stage7.hamming_weight_claim_reduction.oracle",
-        });
-    };
-    let point = store.try_point(&symbol).ok_or(VerifyStage7Error::MissingValue {
-        symbol: "stage7.hamming_weight_claim_reduction.virtualization_point",
-    })?;
-    point
-        .get(..log_k_chunk)
-        .ok_or(VerifyStage7Error::InvalidInputLength {
-            input: "stage7.hamming_weight_claim_reduction.virtualization_point",
-            expected: log_k_chunk,
-            actual: point.len(),
-        })
-}
-
-fn stage7_trace_rounds(
-    program: &'static Stage7VerifierProgramPlan,
-) -> Result<usize, VerifyStage7Error> {
-    program
-        .instance_results
-        .iter()
-        .find(|instance| instance.relation == "jolt.stage7.hamming_booleanity")
-        .map(|instance| instance.num_rounds)
-        .ok_or(VerifyStage7Error::MissingValue {
-            symbol: "stage7.hamming_booleanity.instance",
-        })
-}
diff --git a/crates/jolt-verifier/src/stages/stage8.rs b/crates/jolt-verifier/src/stages/stage8.rs
index 6d245c8ba9..5d8a79c12c 100644
--- a/crates/jolt-verifier/src/stages/stage8.rs
+++ b/crates/jolt-verifier/src/stages/stage8.rs
@@ -1,53 +1,76 @@
 #![allow(clippy::too_many_lines)]
 
+pub use bolt_verifier_runtime::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, StageParams as Stage8Params, TypedPlanSymbol};
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Stage8Params {
-    pub field: &'static str,
-    pub pcs: &'static str,
-    pub transcript: &'static str,
+pub enum Stage8SourceStage {
+    Stage6,
+    Stage7,
+}
+
+impl Stage8SourceStage {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Stage6 => "stage6",
+            Self::Stage7 => "stage7",
+        }
+    }
 }
 
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Stage8OpeningInputTag {}
+pub type Stage8OpeningInputSymbol = TypedPlanSymbol<Stage8OpeningInputTag>;
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Stage8OpeningClaimTag {}
+pub type Stage8OpeningClaimSymbol = TypedPlanSymbol<Stage8OpeningClaimTag>;
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Stage8OpeningBatchTag {}
+pub type Stage8OpeningBatchSymbol = TypedPlanSymbol<Stage8OpeningBatchTag>;
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Stage8SourceClaimTag {}
+pub type Stage8SourceClaim = TypedPlanSymbol<Stage8SourceClaimTag>;
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Stage8OpeningInputPlan {
-    pub symbol: &'static str,
-    pub source_stage: &'static str,
-    pub source_claim: &'static str,
+    pub symbol: Stage8OpeningInputSymbol,
+    pub source_stage: Stage8SourceStage,
+    pub source_claim: Stage8SourceClaim,
     pub oracle: &'static str,
     pub domain: &'static str,
     pub point_arity: usize,
-    pub claim_kind: &'static str,
+    pub claim_kind: Stage8ClaimKind,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Stage8OpeningClaimPlan {
-    pub symbol: &'static str,
+    pub symbol: Stage8OpeningClaimSymbol,
     pub oracle: &'static str,
     pub family: &'static str,
     pub domain: &'static str,
     pub point_arity: usize,
-    pub point_source: &'static str,
-    pub eval_source: &'static str,
-    pub source_stage: &'static str,
-    pub source_claim: &'static str,
+    pub point_source: Stage8OpeningInputSymbol,
+    pub eval_source: Stage8OpeningInputSymbol,
+    pub source_stage: Stage8SourceStage,
+    pub source_claim: Stage8SourceClaim,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Stage8OpeningBatchPlan {
-    pub symbol: &'static str,
+    pub symbol: Stage8OpeningBatchSymbol,
     pub proof_slot: &'static str,
     pub policy: &'static str,
     pub count: usize,
-    pub ordered_claims: &'static [&'static str],
+    pub ordered_claims: &'static [Stage8OpeningClaimPlan],
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Stage8PcsProofPlan {
     pub symbol: &'static str,
-    pub mode: &'static str,
+    pub mode: Stage8PcsProofMode,
     pub pcs: &'static str,
     pub proof_slot: &'static str,
     pub transcript_label: &'static str,
-    pub batch: &'static str,
+    pub batch: Stage8OpeningBatchSymbol,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -62,112 +85,336 @@ pub struct Stage8EvaluationProgramPlan {
     pub pcs_proof: Stage8PcsProofPlan,
 }
 
+const fn stage8_opening_input(
+    symbol: &'static str,
+    source_stage: Stage8SourceStage,
+    source_claim: &'static str,
+    oracle: &'static str,
+    domain: &'static str,
+    point_arity: usize,
+    claim_kind: Stage8ClaimKind,
+) -> Stage8OpeningInputPlan {
+    Stage8OpeningInputPlan {
+        symbol: Stage8OpeningInputSymbol::new(symbol),
+        source_stage,
+        source_claim: Stage8SourceClaim::new(source_claim),
+        oracle,
+        domain,
+        point_arity,
+        claim_kind,
+    }
+}
+
+const fn stage8_opening_claim(
+    symbol: &'static str,
+    oracle: &'static str,
+    family: &'static str,
+    domain: &'static str,
+    point_arity: usize,
+    input_symbol: &'static str,
+    source: (Stage8SourceStage, &'static str),
+) -> Stage8OpeningClaimPlan {
+    Stage8OpeningClaimPlan {
+        symbol: Stage8OpeningClaimSymbol::new(symbol),
+        oracle,
+        family,
+        domain,
+        point_arity,
+        point_source: Stage8OpeningInputSymbol::new(input_symbol),
+        eval_source: Stage8OpeningInputSymbol::new(input_symbol),
+        source_stage: source.0,
+        source_claim: Stage8SourceClaim::new(source.1),
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage8EvaluationClaim<F> {
+    pub oracle: &'static str,
+    pub source_stage: Stage8SourceStage,
+    pub value: F,
+}
+
+pub fn reverse_point<F: Copy>(point: &[F]) -> Vec<F> {
+    point.iter().rev().copied().collect()
+}
+
+pub fn append_rlc_claims<F, T>(transcript: &mut T, claims: &[Stage8EvaluationClaim<F>])
+where
+    F: jolt_field::Field + jolt_transcript::AppendToTranscript,
+    T: jolt_transcript::Transcript<Challenge = F>,
+{
+    transcript.append(&jolt_transcript::LabelWithCount(
+        b"rlc_claims",
+        claims.len() as u64,
+    ));
+    for claim in claims {
+        jolt_transcript::AppendToTranscript::append_to_transcript(&claim.value, transcript);
+    }
+}
+
+pub fn gamma_powers<F, T>(transcript: &mut T, count: usize) -> Vec<F>
+where
+    F: jolt_field::Field,
+    T: jolt_transcript::Transcript<Challenge = F>,
+{
+    let gamma = transcript.challenge();
+    let mut powers = Vec::with_capacity(count);
+    let mut power = F::from_u64(1);
+    for _ in 0..count {
+        powers.push(power);
+        power *= gamma;
+    }
+    powers
+}
+
+pub trait Stage8NamedEvalView<F> {
+    fn name(&self) -> &'static str;
+    fn value(&self) -> F;
+}
+
+pub trait Stage8SumcheckOutputView<F> {
+    type Eval: Stage8NamedEvalView<F>;
+
+    fn point(&self) -> &[F];
+    fn evals(&self) -> &[Self::Eval];
+}
+
+pub fn stage7_claim_values<F, O>(
+    program: &'static Stage8EvaluationProgramPlan,
+    outputs: &[O],
+) -> Option<(Vec<F>, std::collections::BTreeMap<Stage8SourceClaim, F>)>
+where
+    F: Copy,
+    O: Stage8SumcheckOutputView<F>,
+{
+    let stage7_plans = program
+        .opening_claims
+        .iter()
+        .filter(|plan| plan.source_stage == Stage8SourceStage::Stage7)
+        .collect::<Vec<_>>();
+    for output in outputs {
+        let mut values = std::collections::BTreeMap::new();
+        for plan in &stage7_plans {
+            if let Some(eval) = output
+                .evals()
+                .iter()
+                .find(|eval| eval.name() == plan.source_claim.as_str())
+            {
+                let _ = values.insert(plan.source_claim, eval.value());
+            }
+        }
+        if values.len() == stage7_plans.len() {
+            return Some((output.point().to_vec(), values));
+        }
+    }
+    None
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage8EvaluationClaimError {
+    pub stage: &'static str,
+    pub eval: &'static str,
+}
+
+pub fn evaluation_claims<F, O>(
+    program: &'static Stage8EvaluationProgramPlan,
+    stage6_outputs: &[O],
+    stage7_values: &std::collections::BTreeMap<Stage8SourceClaim, F>,
+    lagrange_factor: F,
+) -> Result<Vec<Stage8EvaluationClaim<F>>, Stage8EvaluationClaimError>
+where
+    F: Copy + std::ops::Mul<Output = F>,
+    O: Stage8SumcheckOutputView<F>,
+{
+    let mut claims = Vec::with_capacity(program.opening_claims.len());
+    for plan in program.opening_claims {
+        let value = match plan.source_stage {
+            Stage8SourceStage::Stage6 => {
+                stage_eval(stage6_outputs, plan.source_stage.as_str(), plan.source_claim)?
+                    * lagrange_factor
+            }
+            Stage8SourceStage::Stage7 => *stage7_values.get(&plan.source_claim).ok_or(
+                Stage8EvaluationClaimError {
+                    stage: plan.source_stage.as_str(),
+                    eval: plan.source_claim.as_str(),
+                },
+            )?,
+        };
+        claims.push(Stage8EvaluationClaim {
+            oracle: plan.oracle,
+            source_stage: plan.source_stage,
+            value,
+        });
+    }
+    Ok(claims)
+}
+
+fn stage_eval<F, O>(
+    outputs: &[O],
+    stage: &'static str,
+    eval_name: Stage8SourceClaim,
+) -> Result<F, Stage8EvaluationClaimError>
+where
+    F: Copy,
+    O: Stage8SumcheckOutputView<F>,
+{
+    for output in outputs {
+        let eval = output
+            .evals()
+            .iter()
+            .find(|eval| eval.name() == eval_name.as_str());
+        if let Some(eval) = eval { return Ok(eval.value()); }
+    }
+    Err(Stage8EvaluationClaimError {
+        stage,
+        eval: eval_name.as_str(),
+    })
+}
+
+pub trait Stage8OpeningInputView<F> {
+    fn symbol(&self) -> &'static str;
+    fn point(&self) -> &[F];
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage8EvaluationOpeningPointError {
+    MissingStage7EvaluationPoint,
+    InvalidPointLength {
+        artifact: &'static str,
+        expected: usize,
+        actual: usize,
+    },
+}
+
+pub fn stage7_evaluation_opening_point<F, I>(
+    program: &'static Stage8EvaluationProgramPlan,
+    address_point: &[F],
+    stage7_openings: &[I],
+) -> Result<(Vec<F>, usize), Stage8EvaluationOpeningPointError>
+where
+    F: Copy,
+    I: Stage8OpeningInputView<F>,
+{
+    let cycle_source_symbol = program.evaluation_point_source.source_claim;
+    let cycle_source = stage7_openings
+        .iter()
+        .find(|input| input.symbol() == cycle_source_symbol.as_str())
+        .ok_or(Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint)?;
+    let cycle_source_point = cycle_source.point();
+    if cycle_source_point.len() < address_point.len() {
+        return Err(Stage8EvaluationOpeningPointError::InvalidPointLength {
+            artifact: cycle_source_symbol.as_str(),
+            expected: address_point.len(),
+            actual: cycle_source_point.len(),
+        });
+    }
+    let cycle_len = cycle_source_point.len() - address_point.len();
+    let mut point = Vec::with_capacity(cycle_source_point.len());
+    point.extend_from_slice(address_point);
+    point.extend_from_slice(&cycle_source_point[address_point.len()..]);
+    Ok((point, cycle_len))
+}
+
 pub const STAGE8_PARAMS: Stage8Params = Stage8Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" };
 
-pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = Stage8OpeningInputPlan { symbol: "stage8.evaluation.point_source", source_stage: "stage7", source_claim: "stage7.input.stage6.booleanity.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" };
+pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = stage8_opening_input("stage8.evaluation.point_source", Stage8SourceStage::Stage7, "stage7.input.stage6.booleanity.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed);
 
+#[rustfmt::skip]
 pub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[
-    Stage8OpeningInputPlan { symbol: "stage8.evaluation.point_source", source_stage: "stage7", source_claim: "stage7.input.stage6.booleanity.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage6.RamInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RamInc", oracle: "RamInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage6.RdInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RdInc", oracle: "RdInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_4", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_5", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_6", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_7", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_8", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_9", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_10", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_11", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_12", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_13", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_14", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_15", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_16", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_17", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_18", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_19", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_20", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_21", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_22", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_23", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_24", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_25", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_26", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_27", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_28", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_29", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_30", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_31", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
-    Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" },
+    stage8_opening_input("stage8.evaluation.point_source", Stage8SourceStage::Stage7, "stage7.input.stage6.booleanity.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage6.RamInc", Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RamInc", "RamInc", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage6.RdInc", Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RdInc", "RdInc", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "InstructionRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "InstructionRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_3", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "InstructionRa_3", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_4", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "InstructionRa_4", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_5", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "InstructionRa_5", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_6", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "InstructionRa_6", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_7", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "InstructionRa_7", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_8", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "InstructionRa_8", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_9", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "InstructionRa_9", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_10", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "InstructionRa_10", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_11", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "InstructionRa_11", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_12", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "InstructionRa_12", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_13", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "InstructionRa_13", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_14", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "InstructionRa_14", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_15", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "InstructionRa_15", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_16", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "InstructionRa_16", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_17", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "InstructionRa_17", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_18", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "InstructionRa_18", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_19", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "InstructionRa_19", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_20", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "InstructionRa_20", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_21", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "InstructionRa_21", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_22", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "InstructionRa_22", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_23", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "InstructionRa_23", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_24", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "InstructionRa_24", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_25", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "InstructionRa_25", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_26", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "InstructionRa_26", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_27", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "InstructionRa_27", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_28", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "InstructionRa_28", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_29", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "InstructionRa_29", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_30", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "InstructionRa_30", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.InstructionRa_31", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "InstructionRa_31", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.BytecodeRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "BytecodeRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.BytecodeRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "BytecodeRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.BytecodeRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "BytecodeRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.RamRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "RamRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.RamRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "RamRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.RamRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "RamRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
+    stage8_opening_input("stage8.input.stage7.RamRa_3", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "RamRa_3", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed),
 ];
 
+#[rustfmt::skip]
 pub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamInc", oracle: "RamInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage6.RamInc", eval_source: "stage8.input.stage6.RamInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RamInc" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RdInc", oracle: "RdInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage6.RdInc", eval_source: "stage8.input.stage6.RdInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RdInc" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_0", oracle: "InstructionRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_0", eval_source: "stage8.input.stage7.InstructionRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_1", oracle: "InstructionRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_1", eval_source: "stage8.input.stage7.InstructionRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_2", oracle: "InstructionRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_2", eval_source: "stage8.input.stage7.InstructionRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_3", oracle: "InstructionRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_3", eval_source: "stage8.input.stage7.InstructionRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_4", oracle: "InstructionRa_4", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_4", eval_source: "stage8.input.stage7.InstructionRa_4", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_5", oracle: "InstructionRa_5", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_5", eval_source: "stage8.input.stage7.InstructionRa_5", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_6", oracle: "InstructionRa_6", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_6", eval_source: "stage8.input.stage7.InstructionRa_6", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_7", oracle: "InstructionRa_7", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_7", eval_source: "stage8.input.stage7.InstructionRa_7", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_8", oracle: "InstructionRa_8", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_8", eval_source: "stage8.input.stage7.InstructionRa_8", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_9", oracle: "InstructionRa_9", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_9", eval_source: "stage8.input.stage7.InstructionRa_9", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_10", oracle: "InstructionRa_10", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_10", eval_source: "stage8.input.stage7.InstructionRa_10", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_11", oracle: "InstructionRa_11", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_11", eval_source: "stage8.input.stage7.InstructionRa_11", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_12", oracle: "InstructionRa_12", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_12", eval_source: "stage8.input.stage7.InstructionRa_12", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_13", oracle: "InstructionRa_13", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_13", eval_source: "stage8.input.stage7.InstructionRa_13", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_14", oracle: "InstructionRa_14", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_14", eval_source: "stage8.input.stage7.InstructionRa_14", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_15", oracle: "InstructionRa_15", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_15", eval_source: "stage8.input.stage7.InstructionRa_15", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_16", oracle: "InstructionRa_16", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_16", eval_source: "stage8.input.stage7.InstructionRa_16", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_17", oracle: "InstructionRa_17", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_17", eval_source: "stage8.input.stage7.InstructionRa_17", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_18", oracle: "InstructionRa_18", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_18", eval_source: "stage8.input.stage7.InstructionRa_18", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_19", oracle: "InstructionRa_19", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_19", eval_source: "stage8.input.stage7.InstructionRa_19", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_20", oracle: "InstructionRa_20", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_20", eval_source: "stage8.input.stage7.InstructionRa_20", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_21", oracle: "InstructionRa_21", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_21", eval_source: "stage8.input.stage7.InstructionRa_21", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_22", oracle: "InstructionRa_22", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_22", eval_source: "stage8.input.stage7.InstructionRa_22", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_23", oracle: "InstructionRa_23", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_23", eval_source: "stage8.input.stage7.InstructionRa_23", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_24", oracle: "InstructionRa_24", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_24", eval_source: "stage8.input.stage7.InstructionRa_24", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_25", oracle: "InstructionRa_25", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_25", eval_source: "stage8.input.stage7.InstructionRa_25", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_26", oracle: "InstructionRa_26", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_26", eval_source: "stage8.input.stage7.InstructionRa_26", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_27", oracle: "InstructionRa_27", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_27", eval_source: "stage8.input.stage7.InstructionRa_27", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_28", oracle: "InstructionRa_28", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_28", eval_source: "stage8.input.stage7.InstructionRa_28", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_29", oracle: "InstructionRa_29", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_29", eval_source: "stage8.input.stage7.InstructionRa_29", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_30", oracle: "InstructionRa_30", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_30", eval_source: "stage8.input.stage7.InstructionRa_30", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_31", oracle: "InstructionRa_31", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_31", eval_source: "stage8.input.stage7.InstructionRa_31", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_0", oracle: "BytecodeRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_0", eval_source: "stage8.input.stage7.BytecodeRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_1", oracle: "BytecodeRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_1", eval_source: "stage8.input.stage7.BytecodeRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_2", oracle: "BytecodeRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_2", eval_source: "stage8.input.stage7.BytecodeRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_0", oracle: "RamRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_0", eval_source: "stage8.input.stage7.RamRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_0" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_1", oracle: "RamRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_1", eval_source: "stage8.input.stage7.RamRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_1" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_2", oracle: "RamRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_2", eval_source: "stage8.input.stage7.RamRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_2" },
-    Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_3", oracle: "RamRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_3", eval_source: "stage8.input.stage7.RamRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_3" },
+    stage8_opening_claim("stage8.evaluation.opening.RamInc", "RamInc", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage6.RamInc", (Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RamInc")),
+    stage8_opening_claim("stage8.evaluation.opening.RdInc", "RdInc", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage6.RdInc", (Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RdInc")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_1", "InstructionRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_2", "InstructionRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_3", "InstructionRa_3", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_3", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_4", "InstructionRa_4", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_4", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_5", "InstructionRa_5", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_5", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_6", "InstructionRa_6", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_6", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_7", "InstructionRa_7", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_7", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_8", "InstructionRa_8", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_8", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_9", "InstructionRa_9", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_9", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_10", "InstructionRa_10", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_10", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_11", "InstructionRa_11", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_11", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_12", "InstructionRa_12", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_12", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_13", "InstructionRa_13", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_13", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_14", "InstructionRa_14", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_14", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_15", "InstructionRa_15", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_15", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_16", "InstructionRa_16", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_16", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_17", "InstructionRa_17", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_17", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_18", "InstructionRa_18", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_18", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_19", "InstructionRa_19", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_19", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_20", "InstructionRa_20", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_20", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_21", "InstructionRa_21", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_21", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_22", "InstructionRa_22", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_22", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_23", "InstructionRa_23", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_23", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_24", "InstructionRa_24", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_24", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_25", "InstructionRa_25", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_25", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_26", "InstructionRa_26", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_26", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_27", "InstructionRa_27", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_27", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_28", "InstructionRa_28", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_28", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_29", "InstructionRa_29", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_29", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_30", "InstructionRa_30", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_30", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30")),
+    stage8_opening_claim("stage8.evaluation.opening.InstructionRa_31", "InstructionRa_31", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_31", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31")),
+    stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_0", "BytecodeRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0")),
+    stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_1", "BytecodeRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1")),
+    stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_2", "BytecodeRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2")),
+    stage8_opening_claim("stage8.evaluation.opening.RamRa_0", "RamRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_0")),
+    stage8_opening_claim("stage8.evaluation.opening.RamRa_1", "RamRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_1")),
+    stage8_opening_claim("stage8.evaluation.opening.RamRa_2", "RamRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_2")),
+    stage8_opening_claim("stage8.evaluation.opening.RamRa_3", "RamRa_3", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_3", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_3")),
 ];
 
-pub const STAGE8_OPENING_BATCH_ORDERED_CLAIMS: &[&str] = &["stage8.evaluation.opening.RamInc", "stage8.evaluation.opening.RdInc", "stage8.evaluation.opening.InstructionRa_0", "stage8.evaluation.opening.InstructionRa_1", "stage8.evaluation.opening.InstructionRa_2", "stage8.evaluation.opening.InstructionRa_3", "stage8.evaluation.opening.InstructionRa_4", "stage8.evaluation.opening.InstructionRa_5", "stage8.evaluation.opening.InstructionRa_6", "stage8.evaluation.opening.InstructionRa_7", "stage8.evaluation.opening.InstructionRa_8", "stage8.evaluation.opening.InstructionRa_9", "stage8.evaluation.opening.InstructionRa_10", "stage8.evaluation.opening.InstructionRa_11", "stage8.evaluation.opening.InstructionRa_12", "stage8.evaluation.opening.InstructionRa_13", "stage8.evaluation.opening.InstructionRa_14", "stage8.evaluation.opening.InstructionRa_15", "stage8.evaluation.opening.InstructionRa_16", "stage8.evaluation.opening.InstructionRa_17", "stage8.evaluation.opening.InstructionRa_18", "stage8.evaluation.opening.InstructionRa_19", "stage8.evaluation.opening.InstructionRa_20", "stage8.evaluation.opening.InstructionRa_21", "stage8.evaluation.opening.InstructionRa_22", "stage8.evaluation.opening.InstructionRa_23", "stage8.evaluation.opening.InstructionRa_24", "stage8.evaluation.opening.InstructionRa_25", "stage8.evaluation.opening.InstructionRa_26", "stage8.evaluation.opening.InstructionRa_27", "stage8.evaluation.opening.InstructionRa_28", "stage8.evaluation.opening.InstructionRa_29", "stage8.evaluation.opening.InstructionRa_30", "stage8.evaluation.opening.InstructionRa_31", "stage8.evaluation.opening.BytecodeRa_0", "stage8.evaluation.opening.BytecodeRa_1", "stage8.evaluation.opening.BytecodeRa_2", "stage8.evaluation.opening.RamRa_0", "stage8.evaluation.opening.RamRa_1", "stage8.evaluation.opening.RamRa_2", "stage8.evaluation.opening.RamRa_3"];
-
-pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan { symbol: "stage8.evaluation.openings", proof_slot: "stage8.evaluation", policy: "jolt_stage8_joint_rlc", count: 41, ordered_claims: STAGE8_OPENING_BATCH_ORDERED_CLAIMS };
+#[rustfmt::skip]
+pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan { symbol: Stage8OpeningBatchSymbol::new("stage8.evaluation.openings"), proof_slot: "stage8.evaluation", policy: "jolt_stage8_joint_rlc", count: 41, ordered_claims: STAGE8_OPENING_CLAIMS };
 
-pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan { symbol: "stage8.evaluation.proof", mode: "verify", pcs: "dory", proof_slot: "stage8.evaluation", transcript_label: "rlc_claims", batch: "stage8.evaluation.openings" };
+#[rustfmt::skip]
+pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan { symbol: "stage8.evaluation.proof", mode: Stage8PcsProofMode::Verify, pcs: "dory", proof_slot: "stage8.evaluation", transcript_label: "rlc_claims", batch: Stage8OpeningBatchSymbol::new("stage8.evaluation.openings") };
 
-pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan {
-    role: "verifier",
-    function: "jolt.stage8",
-    params: STAGE8_PARAMS,
-    evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE,
-    opening_inputs: STAGE8_OPENING_INPUTS,
-    opening_claims: STAGE8_OPENING_CLAIMS,
-    opening_batch: STAGE8_OPENING_BATCH,
-    pcs_proof: STAGE8_PCS_PROOF,
-};
+#[rustfmt::skip]
+pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan { role: "verifier", function: "jolt.stage8", params: STAGE8_PARAMS, evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE, opening_inputs: STAGE8_OPENING_INPUTS, opening_claims: STAGE8_OPENING_CLAIMS, opening_batch: STAGE8_OPENING_BATCH, pcs_proof: STAGE8_PCS_PROOF };
diff --git a/crates/jolt-verifier/src/verifier.rs b/crates/jolt-verifier/src/verifier.rs
index 1518cd618c..dcebe535d9 100644
--- a/crates/jolt-verifier/src/verifier.rs
+++ b/crates/jolt-verifier/src/verifier.rs
@@ -4,13 +4,13 @@ use jolt_dory::{DoryCommitment, DoryProof, DoryScheme, DoryVerifierSetup};
 use jolt_field::Fr;
 use jolt_openings::{AdditivelyHomomorphic, CommitmentScheme, OpeningsError};
 use jolt_poly::EqPolynomial;
-use jolt_transcript::{AppendToTranscript, LabelWithCount, Transcript};
+use jolt_transcript::Transcript;
 
 use crate::stages::{commitment as commitment_stage, stage1_outer as stage1_outer_stage, stage2 as stage2_stage, stage3 as stage3_stage, stage4 as stage4_stage, stage5 as stage5_stage, stage6 as stage6_stage, stage7 as stage7_stage, stage8 as stage8_stage};
 
-pub type JoltNamedEval = crate::stages::common::StageNamedEval<Fr>;
-pub type JoltSumcheckOutput = crate::stages::common::StageSumcheckOutput<Fr>;
-pub type JoltStageProof = crate::stages::common::StageProof<Fr>;
+pub type JoltNamedEval = bolt_verifier_runtime::StageNamedEval<Fr>;
+pub type JoltSumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput<Fr>;
+pub type JoltStageProof = bolt_verifier_runtime::StageProof<Fr>;
 
 #[derive(Clone, Debug)]
 pub struct JoltProof {
@@ -28,9 +28,9 @@ pub struct JoltProof {
 pub type JoltStage2RamAccess = crate::stages::stage2::Stage2RamAccess;
 pub type JoltStage2RamOutputLayout = crate::stages::stage2::Stage2RamOutputLayout;
 pub type JoltStage2RamData<'a> = crate::stages::stage2::Stage2RamData<'a>;
-pub type JoltStageChallengeVector = crate::stages::common::StageChallengeVector<Fr>;
-pub type JoltStageExecutionArtifacts = crate::stages::common::StageExecutionArtifacts<Fr>;
-pub type JoltStageOpeningInputValue = crate::stages::common::StageOpeningInputValue<Fr>;
+pub type JoltStageChallengeVector = bolt_verifier_runtime::StageChallengeVector<Fr>;
+pub type JoltStageExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts<Fr>;
+pub type JoltStageOpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue<Fr>;
 
 #[derive(Clone, Debug)]
 pub struct JoltEvaluationProof {
@@ -60,6 +60,7 @@ pub struct JoltVerifierPrograms {
     pub stage5: &'static stage5_stage::Stage5VerifierProgramPlan,
     pub stage6: &'static stage6_stage::Stage6VerifierProgramPlan,
     pub stage7: &'static stage7_stage::Stage7VerifierProgramPlan,
+    pub verifier: &'static JoltVerifierProgramPlan,
     pub stage8: &'static stage8_stage::Stage8EvaluationProgramPlan,
 }
 
@@ -73,6 +74,7 @@ pub fn default_verifier_programs() -> JoltVerifierPrograms {
         stage5: &stage5_stage::STAGE5_PROGRAM,
         stage6: &stage6_stage::STAGE6_PROGRAM,
         stage7: &stage7_stage::STAGE7_PROGRAM,
+        verifier: &VERIFIER_PROGRAM,
         stage8: &stage8_stage::STAGE8_PROGRAM,
     }
 }
@@ -99,24 +101,125 @@ pub enum JoltVerifyError {
     Stage5(stage5_stage::VerifyStage5Error),
     Stage6(stage6_stage::VerifyStage6Error),
     Stage7(stage7_stage::VerifyStage7Error),
+    Program(JoltVerifierProgramError),
     Evaluation(JoltEvaluationProofError),
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum JoltVerifierTarget {
-    ThroughStage5,
-    ThroughStage6,
-    ThroughStage7,
-    Full,
+pub enum JoltProofSlot {
+    Commitments,
+    Stage1Outer,
+    Stage2,
+    Stage3,
+    Stage4,
+    Stage5,
+    Stage6,
+    Stage7,
+    Evaluation,
 }
 
-impl JoltVerifierTarget {
-    fn verifies_stage6(self) -> bool { matches!(self, Self::ThroughStage6 | Self::ThroughStage7 | Self::Full) }
-    fn verifies_stage7(self) -> bool { matches!(self, Self::ThroughStage7 | Self::Full) }
-    fn verifies_evaluation(self) -> bool { matches!(self, Self::Full) }
-    fn allows_optional_evaluation(self) -> bool { matches!(self, Self::ThroughStage7 | Self::Full) }
+pub type JoltVerifierStepKind = bolt_verifier_runtime::VerifierProgramStepKind;
+pub type JoltVerifierStepPlan = bolt_verifier_runtime::VerifierProgramStepPlan<JoltProofSlot>;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum JoltVerifierCheckpoint {
+    AfterStage5,
+    AfterStage6,
+    AfterStage7,
+    AfterEvaluation,
 }
 
+pub type JoltEvaluationPolicy = bolt_verifier_runtime::VerifierEvaluationPolicy;
+pub type JoltVerifierTarget = bolt_verifier_runtime::VerifierTarget<JoltVerifierCheckpoint>;
+pub type JoltVerifierTargetPlan = bolt_verifier_runtime::VerifierTargetPlan<JoltVerifierCheckpoint>;
+pub type JoltVerifierProgramPlan =
+    bolt_verifier_runtime::VerifierProgramPlan<JoltProofSlot, JoltVerifierCheckpoint>;
+pub type JoltVerifierProgramError =
+    bolt_verifier_runtime::VerifierProgramError<JoltProofSlot, JoltVerifierTarget>;
+
+pub const JOLT_TARGET_THROUGH_STAGE5: JoltVerifierTarget = JoltVerifierTarget {
+    checkpoint: JoltVerifierCheckpoint::AfterStage5,
+    evaluation: JoltEvaluationPolicy::Skip,
+};
+
+pub const JOLT_TARGET_THROUGH_STAGE6: JoltVerifierTarget = JoltVerifierTarget {
+    checkpoint: JoltVerifierCheckpoint::AfterStage6,
+    evaluation: JoltEvaluationPolicy::Skip,
+};
+
+pub const JOLT_TARGET_THROUGH_STAGE7: JoltVerifierTarget = JoltVerifierTarget {
+    checkpoint: JoltVerifierCheckpoint::AfterStage7,
+    evaluation: JoltEvaluationPolicy::VerifyIfPresent,
+};
+
+pub const JOLT_TARGET_FULL: JoltVerifierTarget = JoltVerifierTarget {
+    checkpoint: JoltVerifierCheckpoint::AfterEvaluation,
+    evaluation: JoltEvaluationPolicy::Required,
+};
+
+pub const JOLT_VERIFIER_STEPS: &[JoltVerifierStepPlan] = &[
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::ReceiveCommitments,
+        slot: JoltProofSlot::Commitments,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage1Outer,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage2,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage3,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage4,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage5,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage6,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifySumcheckStage,
+        slot: JoltProofSlot::Stage7,
+    },
+    JoltVerifierStepPlan {
+        kind: JoltVerifierStepKind::VerifyPcsOpening,
+        slot: JoltProofSlot::Evaluation,
+    },
+];
+
+pub const JOLT_VERIFIER_TARGETS: &[JoltVerifierTargetPlan] = &[
+    JoltVerifierTargetPlan {
+        target: JOLT_TARGET_THROUGH_STAGE5,
+        step_count: 6,
+    },
+    JoltVerifierTargetPlan {
+        target: JOLT_TARGET_THROUGH_STAGE6,
+        step_count: 7,
+    },
+    JoltVerifierTargetPlan {
+        target: JOLT_TARGET_THROUGH_STAGE7,
+        step_count: 9,
+    },
+    JoltVerifierTargetPlan {
+        target: JOLT_TARGET_FULL,
+        step_count: 9,
+    },
+];
+
+pub const VERIFIER_PROGRAM: JoltVerifierProgramPlan = JoltVerifierProgramPlan {
+    steps: JOLT_VERIFIER_STEPS,
+    targets: JOLT_VERIFIER_TARGETS,
+};
+
 #[derive(Debug)]
 pub enum JoltEvaluationProofError {
     MissingProof,
@@ -152,6 +255,12 @@ define_jolt_verify_error_from!(stage5_stage, VerifyStage5Error, Stage5);
 define_jolt_verify_error_from!(stage6_stage, VerifyStage6Error, Stage6);
 define_jolt_verify_error_from!(stage7_stage, VerifyStage7Error, Stage7);
 
+impl From<JoltVerifierProgramError> for JoltVerifyError {
+    fn from(error: JoltVerifierProgramError) -> Self {
+        Self::Program(error)
+    }
+}
+
 impl From<JoltEvaluationProofError> for JoltVerifyError {
     fn from(error: JoltEvaluationProofError) -> Self {
         Self::Evaluation(error)
@@ -177,66 +286,225 @@ pub fn verify_jolt_through_stage6<T: Transcript<Challenge = Fr>>(proof: &JoltPro
 pub fn verify_jolt_through_stage7<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_through_stage7_with_programs(proof, inputs, default_verifier_programs(), transcript) }
 
 pub fn verify_jolt_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> {
-    verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::Full)
+    verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_FULL)
 }
 
-pub fn verify_jolt_through_stage5_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage5) }
+pub fn verify_jolt_through_stage5_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE5) }
 
-pub fn verify_jolt_through_stage6_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage6) }
+pub fn verify_jolt_through_stage6_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE6) }
 
-pub fn verify_jolt_through_stage7_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage7) }
+pub fn verify_jolt_through_stage7_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE7) }
 
 pub fn verify_jolt_prefix_with_programs<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result<JoltVerificationArtifacts, JoltVerifyError> { verify_jolt_through_stage7_with_programs(proof, inputs, programs, transcript) }
 
 fn verify_jolt_with_programs_inner<T: Transcript<Challenge = Fr>>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T, target: JoltVerifierTarget) -> Result<JoltVerificationArtifacts, JoltVerifyError> {
     let _verify_span = tracing::info_span!("bolt.verify").entered();
-    let commitment = commitment_stage::verify_commitment_phase_with_program(programs.commitment, &proof.commitments, transcript)?;
-    let stage1_outer = stage1_outer_stage::verify_stage1_outer_with_program(programs.stage1_outer, &proof.stage1_outer, transcript)?;
-    let stage2 = stage2_stage::verify_stage2_with_program(programs.stage2, &proof.stage2, inputs.stage2_openings, inputs.stage2_ram, transcript)?;
-    let stage3 = stage3_stage::verify_stage3_with_program(programs.stage3, &proof.stage3, inputs.stage3_openings, transcript)?;
-    let stage4 = stage4_stage::verify_stage4_with_program(programs.stage4, &proof.stage4, inputs.stage4_openings, transcript)?;
-    let stage5 = stage5_stage::verify_stage5_with_program(programs.stage5, &proof.stage5, inputs.stage5_openings, transcript)?;
-    let stage6 = if target.verifies_stage6() {
-        stage6_stage::verify_stage6_with_program(programs.stage6, &proof.stage6, inputs.stage6_openings, inputs.stage6_data, transcript)?
-    } else {
-        stage6_stage::Stage6ExecutionArtifacts::default()
-    };
-    let stage7 = if target.verifies_stage7() {
-        stage7_stage::verify_stage7_with_program(programs.stage7, &proof.stage7, inputs.stage7_openings, transcript)?
-    } else {
-        stage7_stage::Stage7ExecutionArtifacts::default()
-    };
-    if target.allows_optional_evaluation() {
-        match (&proof.evaluation, inputs.evaluation_setup) {
-            (Some(evaluation), Some(setup)) => {
-                verify_jolt_evaluation_proof(
-                    programs.stage8,
-                    evaluation,
-                    &commitment,
-                    &proof.stage6,
-                    &proof.stage7,
-                    inputs.stage7_openings,
-                    setup,
-                    transcript,
-                )?;
+    execute_jolt_verifier_program(proof, inputs, programs, transcript, target)
+}
+
+fn execute_jolt_verifier_program<T>(
+    proof: &JoltProof,
+    inputs: JoltVerifierInputs<'_>,
+    programs: JoltVerifierPrograms,
+    transcript: &mut T,
+    target: JoltVerifierTarget,
+) -> Result<JoltVerificationArtifacts, JoltVerifyError>
+where
+    T: Transcript<Challenge = Fr>,
+{
+    let mut artifacts = JoltArtifactStore::default();
+    bolt_verifier_runtime::execute_verifier_program(programs.verifier, target, |step| {
+        execute_jolt_verifier_step(
+            step,
+            proof,
+            inputs,
+            programs,
+            transcript,
+            target.evaluation,
+            &mut artifacts,
+        )
+    })?;
+    artifacts.into_public_artifacts().map_err(JoltVerifyError::from)
+}
+
+fn execute_jolt_verifier_step<T>(
+    step: JoltVerifierStepPlan,
+    proof: &JoltProof,
+    inputs: JoltVerifierInputs<'_>,
+    programs: JoltVerifierPrograms,
+    transcript: &mut T,
+    evaluation: JoltEvaluationPolicy,
+    artifacts: &mut JoltArtifactStore,
+) -> Result<(), JoltVerifyError>
+where
+    T: Transcript<Challenge = Fr>,
+{
+    let step_plan = step;
+    match (step.kind, step.slot) {
+        (JoltVerifierStepKind::ReceiveCommitments, JoltProofSlot::Commitments) => {
+            artifacts.commitment = Some(commitment_stage::verify_commitment_phase_with_program(
+                programs.commitment,
+                &proof.commitments,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage1Outer) => {
+            artifacts.stage1_outer = Some(stage1_outer_stage::verify_stage1_outer_with_program(
+                programs.stage1_outer,
+                &proof.stage1_outer,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage2) => {
+            artifacts.stage2 = Some(stage2_stage::verify_stage2_with_program(
+                programs.stage2,
+                &proof.stage2,
+                inputs.stage2_openings,
+                inputs.stage2_ram,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage3) => {
+            artifacts.stage3 = Some(stage3_stage::verify_stage3_with_program(
+                programs.stage3,
+                &proof.stage3,
+                inputs.stage3_openings,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage4) => {
+            artifacts.stage4 = Some(stage4_stage::verify_stage4_with_program(
+                programs.stage4,
+                &proof.stage4,
+                inputs.stage4_openings,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage5) => {
+            artifacts.stage5 = Some(stage5_stage::verify_stage5_with_program(
+                programs.stage5,
+                &proof.stage5,
+                inputs.stage5_openings,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage6) => {
+            artifacts.stage6 = Some(stage6_stage::verify_stage6_with_program(
+                programs.stage6,
+                &proof.stage6,
+                inputs.stage6_openings,
+                inputs.stage6_data,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage7) => {
+            artifacts.stage7 = Some(stage7_stage::verify_stage7_with_program(
+                programs.stage7,
+                &proof.stage7,
+                inputs.stage7_openings,
+                transcript,
+            )?);
+        }
+        (JoltVerifierStepKind::VerifyPcsOpening, JoltProofSlot::Evaluation) => {
+            verify_jolt_evaluation_step(
+                evaluation,
+                proof,
+                inputs,
+                programs,
+                transcript,
+                artifacts,
+            )?;
+        }
+        _ => {
+            return Err(JoltVerifierProgramError::UnsupportedStep {
+                step: step_plan,
+                reason: "step kind and proof slot are incompatible",
             }
-            (Some(_), None) => return Err(JoltEvaluationProofError::MissingVerifierSetup.into()),
-            (None, Some(_)) => return Err(JoltEvaluationProofError::MissingProof.into()),
-            (None, None) if target.verifies_evaluation() => return Err(JoltEvaluationProofError::MissingProof.into()),
-            (None, None) => {}
+            .into());
         }
     }
+    Ok(())
+}
 
-    Ok(JoltVerificationArtifacts {
-        commitment,
-        stage1_outer,
-        stage2,
-        stage3,
-        stage4,
-        stage5,
-        stage6,
-        stage7,
-    })
+fn verify_jolt_evaluation_step<T>(
+    evaluation: JoltEvaluationPolicy,
+    proof: &JoltProof,
+    inputs: JoltVerifierInputs<'_>,
+    programs: JoltVerifierPrograms,
+    transcript: &mut T,
+    artifacts: &JoltArtifactStore,
+) -> Result<(), JoltVerifyError>
+where
+    T: Transcript<Challenge = Fr>,
+{
+    if evaluation == JoltEvaluationPolicy::Skip {
+        return Ok(());
+    }
+    match (&proof.evaluation, inputs.evaluation_setup) {
+        (Some(evaluation_proof), Some(setup)) => {
+            verify_jolt_evaluation_proof(
+                programs.stage8,
+                evaluation_proof,
+                artifacts.commitment()?,
+                &proof.stage6,
+                &proof.stage7,
+                inputs.stage7_openings,
+                setup,
+                transcript,
+            )?;
+        }
+        (Some(_), None) => return Err(JoltEvaluationProofError::MissingVerifierSetup.into()),
+        (None, Some(_)) => return Err(JoltEvaluationProofError::MissingProof.into()),
+        (None, None) if evaluation == JoltEvaluationPolicy::Required => {
+            return Err(JoltEvaluationProofError::MissingProof.into());
+        }
+        (None, None) => {}
+    }
+    Ok(())
+}
+
+#[derive(Default)]
+struct JoltArtifactStore {
+    commitment: Option<commitment_stage::CommitmentArtifacts>,
+    stage1_outer: Option<stage1_outer_stage::Stage1ExecutionArtifacts<Fr>>,
+    stage2: Option<stage2_stage::Stage2ExecutionArtifacts<Fr>>,
+    stage3: Option<stage3_stage::Stage3ExecutionArtifacts<Fr>>,
+    stage4: Option<stage4_stage::Stage4ExecutionArtifacts<Fr>>,
+    stage5: Option<stage5_stage::Stage5ExecutionArtifacts<Fr>>,
+    stage6: Option<stage6_stage::Stage6ExecutionArtifacts<Fr>>,
+    stage7: Option<stage7_stage::Stage7ExecutionArtifacts<Fr>>,
+}
+
+impl JoltArtifactStore {
+    fn commitment(
+        &self,
+    ) -> Result<&commitment_stage::CommitmentArtifacts, JoltVerifierProgramError> {
+        self.commitment
+            .as_ref()
+            .ok_or(JoltVerifierProgramError::MissingArtifact {
+                slot: JoltProofSlot::Commitments,
+            })
+    }
+
+    fn into_public_artifacts(self) -> Result<JoltVerificationArtifacts, JoltVerifierProgramError> {
+        Ok(JoltVerificationArtifacts {
+            commitment: required_artifact(self.commitment, JoltProofSlot::Commitments)?,
+            stage1_outer: required_artifact(self.stage1_outer, JoltProofSlot::Stage1Outer)?,
+            stage2: required_artifact(self.stage2, JoltProofSlot::Stage2)?,
+            stage3: required_artifact(self.stage3, JoltProofSlot::Stage3)?,
+            stage4: required_artifact(self.stage4, JoltProofSlot::Stage4)?,
+            stage5: required_artifact(self.stage5, JoltProofSlot::Stage5)?,
+            stage6: self.stage6.unwrap_or_default(),
+            stage7: self.stage7.unwrap_or_default(),
+        })
+    }
+}
+
+fn required_artifact<T>(
+    artifact: Option<T>,
+    slot: JoltProofSlot,
+) -> Result<T, JoltVerifierProgramError> {
+    artifact.ok_or(JoltVerifierProgramError::MissingArtifact { slot })
 }
 
 impl<'a> JoltVerifierInputs<'a> {
@@ -250,6 +518,59 @@ pub type JoltStage6BytecodeEntry = crate::stages::stage6::Stage6BytecodeEntry;
 pub type JoltStage6BytecodeReadRafData = crate::stages::stage6::Stage6BytecodeReadRafData;
 pub type JoltStage6VerifierData = crate::stages::stage6::Stage6VerifierData;
 
+impl stage8_stage::Stage8NamedEvalView<Fr> for JoltNamedEval {
+    fn name(&self) -> &'static str {
+        self.name
+    }
+
+    fn value(&self) -> Fr {
+        self.value
+    }
+}
+
+impl stage8_stage::Stage8SumcheckOutputView<Fr> for JoltSumcheckOutput {
+    type Eval = JoltNamedEval;
+
+    fn point(&self) -> &[Fr] {
+        &self.point
+    }
+
+    fn evals(&self) -> &[Self::Eval] {
+        &self.evals
+    }
+}
+
+impl stage8_stage::Stage8OpeningInputView<Fr>
+    for stage7_stage::Stage7OpeningInputValue<Fr>
+{
+    fn symbol(&self) -> &'static str {
+        self.symbol
+    }
+
+    fn point(&self) -> &[Fr] {
+        &self.point
+    }
+}
+
+impl From<stage8_stage::Stage8EvaluationOpeningPointError> for JoltEvaluationProofError {
+    fn from(error: stage8_stage::Stage8EvaluationOpeningPointError) -> Self {
+        match error {
+            stage8_stage::Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint => {
+                Self::MissingStage7EvaluationPoint
+            }
+            stage8_stage::Stage8EvaluationOpeningPointError::InvalidPointLength {
+                artifact,
+                expected,
+                actual,
+            } => Self::InvalidPointLength {
+                artifact,
+                expected,
+                actual,
+            },
+        }
+    }
+}
+
 #[expect(
     clippy::too_many_arguments,
     reason = "generated verifier entry point follows the Jolt proof artifact boundary"
@@ -297,11 +618,6 @@ struct EvaluationProofState {
     joint_commitment: DoryCommitment,
 }
 
-struct EvaluationClaim {
-    oracle: &'static str,
-    value: Fr,
-}
-
 fn evaluation_proof_state<T>(
     program: &'static stage8_stage::Stage8EvaluationProgramPlan,
     commitments: &commitment_stage::CommitmentArtifacts,
@@ -313,14 +629,22 @@ fn evaluation_proof_state<T>(
 where
     T: Transcript<Challenge = Fr>,
 {
-    let (sumcheck_address_point, stage7_values) = stage7_claim_values(program, stage7)?;
-    let address_point = reverse_point(&sumcheck_address_point);
-    let opening_point = stage7_evaluation_opening_point(program, &address_point, stage7_openings)?;
+    let (sumcheck_address_point, stage7_values) =
+        stage8_stage::stage7_claim_values(program, &stage7.sumchecks)
+            .ok_or(JoltEvaluationProofError::MissingStage7RaEval)?;
+    let address_point = stage8_stage::reverse_point(&sumcheck_address_point);
+    let (opening_point, _) =
+        stage8_stage::stage7_evaluation_opening_point(program, &address_point, stage7_openings)?;
     let lagrange_factor = EqPolynomial::<Fr>::zero_selector(&address_point);
-    let claims = evaluation_claims(program, stage6, &stage7_values, lagrange_factor)?;
-
-    append_rlc_claims(transcript, &claims);
-    let gamma_powers = gamma_powers(transcript, claims.len());
+    let claims =
+        stage8_stage::evaluation_claims(program, &stage6.sumchecks, &stage7_values, lagrange_factor)
+            .map_err(|error| JoltEvaluationProofError::MissingStageEval {
+                stage: error.stage,
+                eval: error.eval,
+            })?;
+
+    stage8_stage::append_rlc_claims(transcript, &claims);
+    let gamma_powers = stage8_stage::gamma_powers(transcript, claims.len());
     let joint_claim = claims
         .iter()
         .zip(&gamma_powers)
@@ -335,130 +659,9 @@ where
     })
 }
 
-fn stage_eval(
-    proof: &JoltStageProof,
-    stage: &'static str,
-    eval_name: &'static str,
-) -> Result<Fr, JoltEvaluationProofError> {
-    for output in &proof.sumchecks {
-        if let Some(eval) = output.evals.iter().find(|eval| eval.name == eval_name) {
-            return Ok(eval.value);
-        }
-    }
-    Err(JoltEvaluationProofError::MissingStageEval {
-        stage,
-        eval: eval_name,
-    })
-}
-
-fn evaluation_claims(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    stage6: &JoltStageProof,
-    stage7_values: &BTreeMap<&'static str, Fr>,
-    lagrange_factor: Fr,
-) -> Result<Vec<EvaluationClaim>, JoltEvaluationProofError> {
-    let mut claims = Vec::with_capacity(program.opening_claims.len());
-    for plan in program.opening_claims {
-        let value = match plan.source_stage {
-            "stage6" => stage_eval(stage6, plan.source_stage, plan.source_claim)? * lagrange_factor,
-            "stage7" => *stage7_values.get(plan.source_claim).ok_or(
-                JoltEvaluationProofError::MissingStageEval {
-                    stage: plan.source_stage,
-                    eval: plan.source_claim,
-                },
-            )?,
-            _ => {
-                return Err(JoltEvaluationProofError::MissingStageEval {
-                    stage: plan.source_stage,
-                    eval: plan.source_claim,
-                });
-            }
-        };
-        claims.push(EvaluationClaim {
-            oracle: plan.oracle,
-            value,
-        });
-    }
-    Ok(claims)
-}
-
-fn stage7_claim_values(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    proof: &JoltStageProof,
-) -> Result<(Vec<Fr>, BTreeMap<&'static str, Fr>), JoltEvaluationProofError> {
-    let stage7_plans = program
-        .opening_claims
-        .iter()
-        .filter(|plan| plan.source_stage == "stage7")
-        .collect::<Vec<_>>();
-    for output in &proof.sumchecks {
-        let mut values = BTreeMap::new();
-        for plan in &stage7_plans {
-            if let Some(eval) = output.evals.iter().find(|eval| eval.name == plan.source_claim) {
-                let _ = values.insert(plan.source_claim, eval.value);
-            }
-        }
-        if values.len() == stage7_plans.len() {
-            return Ok((output.point.clone(), values));
-        }
-    }
-    Err(JoltEvaluationProofError::MissingStage7RaEval)
-}
-
-fn reverse_point(point: &[Fr]) -> Vec<Fr> {
-    point.iter().rev().copied().collect()
-}
-
-fn stage7_evaluation_opening_point(
-    program: &'static stage8_stage::Stage8EvaluationProgramPlan,
-    address_point: &[Fr],
-    stage7_openings: &[stage7_stage::Stage7OpeningInputValue<Fr>],
-) -> Result<Vec<Fr>, JoltEvaluationProofError> {
-    let cycle_source_symbol = program.evaluation_point_source.source_claim;
-    let cycle_source = stage7_openings
-        .iter()
-        .find(|input| input.symbol == cycle_source_symbol)
-        .ok_or(JoltEvaluationProofError::MissingStage7EvaluationPoint)?;
-    if cycle_source.point.len() < address_point.len() {
-        return Err(JoltEvaluationProofError::InvalidPointLength {
-            artifact: cycle_source_symbol,
-            expected: address_point.len(),
-            actual: cycle_source.point.len(),
-        });
-    }
-    let mut point = Vec::with_capacity(cycle_source.point.len());
-    point.extend_from_slice(address_point);
-    point.extend_from_slice(&cycle_source.point[address_point.len()..]);
-    Ok(point)
-}
-
-fn append_rlc_claims<T>(transcript: &mut T, claims: &[EvaluationClaim])
-where
-    T: Transcript<Challenge = Fr>,
-{
-    transcript.append(&LabelWithCount(b"rlc_claims", claims.len() as u64));
-    for claim in claims {
-        claim.value.append_to_transcript(transcript);
-    }
-}
-
-fn gamma_powers<T>(transcript: &mut T, count: usize) -> Vec<Fr>
-where
-    T: Transcript<Challenge = Fr>,
-{
-    let gamma = transcript.challenge();
-    let mut powers = Vec::with_capacity(count);
-    let mut power = Fr::from_u64(1);
-    for _ in 0..count {
-        powers.push(power);
-        power *= gamma;
-    }
-    powers
-}
-
 fn joint_commitment(
     commitments: &commitment_stage::CommitmentArtifacts,
-    claims: &[EvaluationClaim],
+    claims: &[stage8_stage::Stage8EvaluationClaim<Fr>],
     gamma_powers: &[Fr],
 ) -> Result<DoryCommitment, JoltEvaluationProofError> {
     let mut coefficients = BTreeMap::<&'static str, Fr>::new();