diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d2ecd3ba57..ce5cafc981 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -146,9 +146,10 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: tarpaulin
+          # Extend the timeout to 3600 to ensure the code coverage test pass
           args: >
             ${{ steps.prepare.outputs.feature-flags }}
-            --timeout 600
+            --timeout 3600
             --out Xml
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v3.1.4
diff --git a/Cargo.lock b/Cargo.lock
index 2f8bc71dfb..8c33191917 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -30,9 +30,9 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
  "memchr",
 ]
diff --git a/halo2_gadgets/src/ecc.rs b/halo2_gadgets/src/ecc.rs
index 38fab0a49a..86ac8b3f68 100644
--- a/halo2_gadgets/src/ecc.rs
+++ b/halo2_gadgets/src/ecc.rs
@@ -579,6 +579,7 @@ impl<C: CurveAffine, EccChip: EccInstructions<C>> FixedPointShort<C, EccChip> {
 pub(crate) mod tests {
     use ff::PrimeField;
     use group::{prime::PrimeCurveAffine, Curve, Group};
+    use std::marker::PhantomData;
 
     use halo2_proofs::{
         circuit::{Layouter, SimpleFloorPlanner, Value},
@@ -595,7 +596,10 @@ pub(crate) mod tests {
         },
         FixedPoints,
     };
-    use crate::utilities::lookup_range_check::LookupRangeCheckConfig;
+    use crate::{
+        tests::test_utils::test_against_stored_circuit,
+        utilities::lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
+    };
 
     #[derive(Debug, Eq, PartialEq, Clone)]
     pub(crate) struct TestFixedBases;
@@ -723,17 +727,27 @@ pub(crate) mod tests {
         type Base = BaseField;
     }
 
-    struct MyCircuit {
+    struct MyCircuit<Lookup: PallasLookupRangeCheck> {
         test_errors: bool,
+        _lookup_marker: PhantomData<Lookup>,
+    }
+
+    impl<Lookup: PallasLookupRangeCheck> MyCircuit<Lookup> {
+        fn new(test_errors: bool) -> Self {
+            Self {
+                test_errors,
+                _lookup_marker: PhantomData,
+            }
+        }
     }
 
     #[allow(non_snake_case)]
-    impl Circuit<pallas::Base> for MyCircuit {
-        type Config = EccConfig<TestFixedBases>;
+    impl<Lookup: PallasLookupRangeCheck> Circuit<pallas::Base> for MyCircuit<Lookup> {
+        type Config = EccConfig<TestFixedBases, Lookup>;
         type FloorPlanner = SimpleFloorPlanner;
 
         fn without_witnesses(&self) -> Self {
-            MyCircuit { test_errors: false }
+            MyCircuit::new(false)
         }
 
         fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
@@ -764,8 +778,13 @@ pub(crate) mod tests {
             let constants = meta.fixed_column();
             meta.enable_constant(constants);
 
-            let range_check = LookupRangeCheckConfig::configure(meta, advices[9], lookup_table);
-            EccChip::<TestFixedBases>::configure(meta, advices, lagrange_coeffs, range_check)
+            let range_check = Lookup::configure(meta, advices[9], lookup_table);
+            EccChip::<TestFixedBases, Lookup>::configure(
+                meta,
+                advices,
+                lagrange_coeffs,
+                range_check,
+            )
         }
 
         fn synthesize(
@@ -896,11 +915,17 @@ pub(crate) mod tests {
     #[test]
     fn ecc_chip() {
         let k = 13;
-        let circuit = MyCircuit { test_errors: true };
+        let circuit = MyCircuit::<PallasLookupRangeCheckConfig>::new(true);
         let prover = MockProver::run(k, &circuit, vec![]).unwrap();
         assert_eq!(prover.verify(), Ok(()))
     }
 
+    #[test]
+    fn test_ecc_chip_against_stored_circuit() {
+        let circuit = MyCircuit::<PallasLookupRangeCheckConfig>::new(false);
+        test_against_stored_circuit(circuit, "ecc_chip", 3872);
+    }
+
     #[cfg(feature = "test-dev-graph")]
     #[test]
     fn print_ecc_chip() {
@@ -910,7 +935,7 @@ pub(crate) mod tests {
         root.fill(&WHITE).unwrap();
         let root = root.titled("Ecc Chip Layout", ("sans-serif", 60)).unwrap();
 
-        let circuit = MyCircuit { test_errors: false };
+        let circuit = MyCircuit::<PallasLookupRangeCheckConfig>::new(false);
         halo2_proofs::dev::CircuitLayout::default()
             .render(13, &circuit, &root)
             .unwrap();
diff --git a/halo2_gadgets/src/ecc/chip.rs b/halo2_gadgets/src/ecc/chip.rs
index 4d12057afb..8f731fd859 100644
--- a/halo2_gadgets/src/ecc/chip.rs
+++ b/halo2_gadgets/src/ecc/chip.rs
@@ -1,9 +1,9 @@
 //! Chip implementations for the ECC gadgets.
 
 use super::{BaseFitsInScalarInstructions, EccInstructions, FixedPoints};
-use crate::{
-    sinsemilla::primitives as sinsemilla,
-    utilities::{lookup_range_check::LookupRangeCheckConfig, UtilitiesInstructions},
+use crate::utilities::{
+    lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
+    UtilitiesInstructions,
 };
 use arrayvec::ArrayVec;
 
@@ -137,7 +137,10 @@ impl From<NonIdentityEccPoint> for EccPoint {
 /// Configuration for [`EccChip`].
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[allow(non_snake_case)]
-pub struct EccConfig<FixedPoints: super::FixedPoints<pallas::Affine>> {
+pub struct EccConfig<
+    FixedPoints: super::FixedPoints<pallas::Affine>,
+    Lookup: PallasLookupRangeCheck = PallasLookupRangeCheckConfig,
+> {
     /// Advice columns needed by instructions in the ECC chip.
     pub advices: [Column<Advice>; 10],
 
@@ -148,20 +151,20 @@ pub struct EccConfig<FixedPoints: super::FixedPoints<pallas::Affine>> {
     add: add::Config,
 
     /// Variable-base scalar multiplication
-    mul: mul::Config,
+    mul: mul::Config<Lookup>,
 
     /// Fixed-base full-width scalar multiplication
     mul_fixed_full: mul_fixed::full_width::Config<FixedPoints>,
     /// Fixed-base signed short scalar multiplication
     mul_fixed_short: mul_fixed::short::Config<FixedPoints>,
     /// Fixed-base mul using a base field element as a scalar
-    mul_fixed_base_field: mul_fixed::base_field_elem::Config<FixedPoints>,
+    mul_fixed_base_field: mul_fixed::base_field_elem::Config<FixedPoints, Lookup>,
 
     /// Witness point
     witness_point: witness_point::Config,
 
     /// Lookup range check using 10-bit lookup table
-    pub lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
+    pub lookup_config: Lookup,
 }
 
 /// A trait representing the kind of scalar used with a particular `FixedPoint`.
@@ -227,12 +230,17 @@ pub trait FixedPoint<C: CurveAffine>: std::fmt::Debug + Eq + Clone {
 
 /// An [`EccInstructions`] chip that uses 10 advice columns.
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct EccChip<FixedPoints: super::FixedPoints<pallas::Affine>> {
-    config: EccConfig<FixedPoints>,
+pub struct EccChip<
+    FixedPoints: super::FixedPoints<pallas::Affine>,
+    Lookup: PallasLookupRangeCheck = PallasLookupRangeCheckConfig,
+> {
+    config: EccConfig<FixedPoints, Lookup>,
 }
 
-impl<FixedPoints: super::FixedPoints<pallas::Affine>> Chip<pallas::Base> for EccChip<FixedPoints> {
-    type Config = EccConfig<FixedPoints>;
+impl<FixedPoints: super::FixedPoints<pallas::Affine>, Lookup: PallasLookupRangeCheck>
+    Chip<pallas::Base> for EccChip<FixedPoints, Lookup>
+{
+    type Config = EccConfig<FixedPoints, Lookup>;
     type Loaded = ();
 
     fn config(&self) -> &Self::Config {
@@ -244,13 +252,15 @@ impl<FixedPoints: super::FixedPoints<pallas::Affine>> Chip<pallas::Base> for Ecc
     }
 }
 
-impl<Fixed: super::FixedPoints<pallas::Affine>> UtilitiesInstructions<pallas::Base>
-    for EccChip<Fixed>
+impl<Fixed: super::FixedPoints<pallas::Affine>, Lookup: PallasLookupRangeCheck>
+    UtilitiesInstructions<pallas::Base> for EccChip<Fixed, Lookup>
 {
     type Var = AssignedCell<pallas::Base, pallas::Base>;
 }
 
-impl<FixedPoints: super::FixedPoints<pallas::Affine>> EccChip<FixedPoints> {
+impl<FixedPoints: super::FixedPoints<pallas::Affine>, Lookup: PallasLookupRangeCheck>
+    EccChip<FixedPoints, Lookup>
+{
     /// Reconstructs this chip from the given config.
     pub fn construct(config: <Self as Chip<pallas::Base>>::Config) -> Self {
         Self { config }
@@ -264,7 +274,7 @@ impl<FixedPoints: super::FixedPoints<pallas::Affine>> EccChip<FixedPoints> {
         meta: &mut ConstraintSystem<pallas::Base>,
         advices: [Column<Advice>; 10],
         lagrange_coeffs: [Column<Fixed>; 8],
-        range_check: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
+        range_check: Lookup,
     ) -> <Self as Chip<pallas::Base>>::Config {
         // Create witness point gate
         let witness_point = witness_point::Config::configure(meta, advices[0], advices[1]);
@@ -301,12 +311,13 @@ impl<FixedPoints: super::FixedPoints<pallas::Affine>> EccChip<FixedPoints> {
             mul_fixed::short::Config::<FixedPoints>::configure(meta, mul_fixed.clone());
 
         // Create gate that is only used in fixed-base mul using a base field element.
-        let mul_fixed_base_field = mul_fixed::base_field_elem::Config::<FixedPoints>::configure(
-            meta,
-            advices[6..9].try_into().unwrap(),
-            range_check,
-            mul_fixed,
-        );
+        let mul_fixed_base_field =
+            mul_fixed::base_field_elem::Config::<FixedPoints, Lookup>::configure(
+                meta,
+                advices[6..9].try_into().unwrap(),
+                range_check,
+                mul_fixed,
+            );
 
         EccConfig {
             advices,
@@ -407,7 +418,8 @@ pub enum ScalarVar {
     FullWidth,
 }
 
-impl<Fixed: FixedPoints<pallas::Affine>> EccInstructions<pallas::Affine> for EccChip<Fixed>
+impl<Fixed: FixedPoints<pallas::Affine>, Lookup: PallasLookupRangeCheck>
+    EccInstructions<pallas::Affine> for EccChip<Fixed, Lookup>
 where
     <Fixed as FixedPoints<pallas::Affine>>::Base:
         FixedPoint<pallas::Affine, FixedScalarKind = BaseFieldElem>,
@@ -594,8 +606,8 @@ where
     }
 }
 
-impl<Fixed: FixedPoints<pallas::Affine>> BaseFitsInScalarInstructions<pallas::Affine>
-    for EccChip<Fixed>
+impl<Fixed: FixedPoints<pallas::Affine>, Lookup: PallasLookupRangeCheck>
+    BaseFitsInScalarInstructions<pallas::Affine> for EccChip<Fixed, Lookup>
 where
     <Fixed as FixedPoints<pallas::Affine>>::Base:
         FixedPoint<pallas::Affine, FixedScalarKind = BaseFieldElem>,
diff --git a/halo2_gadgets/src/ecc/chip/mul.rs b/halo2_gadgets/src/ecc/chip/mul.rs
index 8e857ae442..2714718a7a 100644
--- a/halo2_gadgets/src/ecc/chip/mul.rs
+++ b/halo2_gadgets/src/ecc/chip/mul.rs
@@ -1,7 +1,7 @@
 use super::{add, EccPoint, NonIdentityEccPoint, ScalarVar, T_Q};
-use crate::{
-    sinsemilla::primitives as sinsemilla,
-    utilities::{bool_check, lookup_range_check::LookupRangeCheckConfig, ternary},
+use crate::utilities::{
+    lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
+    {bool_check, ternary},
 };
 use std::{
     convert::TryInto,
@@ -46,7 +46,7 @@ const INCOMPLETE_LO_LEN: usize = INCOMPLETE_LEN - INCOMPLETE_HI_LEN;
 const COMPLETE_RANGE: Range<usize> = INCOMPLETE_LEN..(INCOMPLETE_LEN + NUM_COMPLETE_BITS);
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct Config {
+pub struct Config<Lookup: PallasLookupRangeCheck = PallasLookupRangeCheckConfig> {
     // Selector used to check switching logic on LSB
     q_mul_lsb: Selector,
     // Configuration used in complete addition
@@ -58,14 +58,14 @@ pub struct Config {
     // Configuration used for complete addition part of double-and-add algorithm
     complete_config: complete::Config,
     // Configuration used to check for overflow
-    overflow_config: overflow::Config,
+    overflow_config: overflow::Config<Lookup>,
 }
 
-impl Config {
+impl<Lookup: PallasLookupRangeCheck> Config<Lookup> {
     pub(super) fn configure(
         meta: &mut ConstraintSystem<pallas::Base>,
         add_config: add::Config,
-        lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
+        lookup_config: Lookup,
         advices: [Column<Advice>; 10],
     ) -> Self {
         let hi_config = incomplete::Config::configure(
@@ -473,13 +473,13 @@ pub mod tests {
             tests::TestFixedBases,
             EccInstructions, NonIdentityPoint, Point, ScalarVar,
         },
-        utilities::UtilitiesInstructions,
+        utilities::{lookup_range_check::PallasLookupRangeCheck, UtilitiesInstructions},
     };
 
-    pub(crate) fn test_mul(
-        chip: EccChip<TestFixedBases>,
+    pub(crate) fn test_mul<Lookup: PallasLookupRangeCheck>(
+        chip: EccChip<TestFixedBases, Lookup>,
         mut layouter: impl Layouter<pallas::Base>,
-        p: &NonIdentityPoint<pallas::Affine, EccChip<TestFixedBases>>,
+        p: &NonIdentityPoint<pallas::Affine, EccChip<TestFixedBases, Lookup>>,
         p_val: pallas::Affine,
     ) -> Result<(), Error> {
         let column = chip.config().advices[0];
diff --git a/halo2_gadgets/src/ecc/chip/mul/overflow.rs b/halo2_gadgets/src/ecc/chip/mul/overflow.rs
index 12101ae82e..fb40781f7c 100644
--- a/halo2_gadgets/src/ecc/chip/mul/overflow.rs
+++ b/halo2_gadgets/src/ecc/chip/mul/overflow.rs
@@ -1,6 +1,7 @@
 use super::{T_Q, Z};
 use crate::{
-    sinsemilla::primitives as sinsemilla, utilities::lookup_range_check::LookupRangeCheckConfig,
+    sinsemilla::primitives as sinsemilla,
+    utilities::lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
 };
 
 use group::ff::PrimeField;
@@ -15,19 +16,19 @@ use pasta_curves::pallas;
 use std::iter;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct Config {
+pub struct Config<Lookup: PallasLookupRangeCheck = PallasLookupRangeCheckConfig> {
     // Selector to check z_0 = alpha + t_q (mod p)
     q_mul_overflow: Selector,
     // 10-bit lookup table
-    lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
+    lookup_config: Lookup,
     // Advice columns
     advices: [Column<Advice>; 3],
 }
 
-impl Config {
+impl<Lookup: PallasLookupRangeCheck> Config<Lookup> {
     pub(super) fn configure(
         meta: &mut ConstraintSystem<pallas::Base>,
-        lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
+        lookup_config: Lookup,
         advices: [Column<Advice>; 3],
     ) -> Self {
         for advice in advices.iter() {
diff --git a/halo2_gadgets/src/ecc/chip/mul_fixed/base_field_elem.rs b/halo2_gadgets/src/ecc/chip/mul_fixed/base_field_elem.rs
index 9a2b0c76ce..0e0bc7ee4b 100644
--- a/halo2_gadgets/src/ecc/chip/mul_fixed/base_field_elem.rs
+++ b/halo2_gadgets/src/ecc/chip/mul_fixed/base_field_elem.rs
@@ -1,10 +1,10 @@
 use super::super::{EccBaseFieldElemFixed, EccPoint, FixedPoints, NUM_WINDOWS, T_P};
 use super::H_BASE;
 
-use crate::utilities::bool_check;
-use crate::{
-    sinsemilla::primitives as sinsemilla,
-    utilities::{bitrange_subset, lookup_range_check::LookupRangeCheckConfig, range_check},
+use crate::utilities::{
+    bitrange_subset, bool_check,
+    lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
+    range_check,
 };
 
 use group::ff::PrimeField;
@@ -18,18 +18,21 @@ use pasta_curves::pallas;
 use std::convert::TryInto;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Config<Fixed: FixedPoints<pallas::Affine>> {
+pub struct Config<
+    Fixed: FixedPoints<pallas::Affine>,
+    Lookup: PallasLookupRangeCheck = PallasLookupRangeCheckConfig,
+> {
     q_mul_fixed_base_field: Selector,
     canon_advices: [Column<Advice>; 3],
-    lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
+    lookup_config: Lookup,
     super_config: super::Config<Fixed>,
 }
 
-impl<Fixed: FixedPoints<pallas::Affine>> Config<Fixed> {
+impl<Fixed: FixedPoints<pallas::Affine>, Lookup: PallasLookupRangeCheck> Config<Fixed, Lookup> {
     pub(crate) fn configure(
         meta: &mut ConstraintSystem<pallas::Base>,
         canon_advices: [Column<Advice>; 3],
-        lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
+        lookup_config: Lookup,
         super_config: super::Config<Fixed>,
     ) -> Self {
         for advice in canon_advices.iter() {
@@ -394,11 +397,11 @@ pub mod tests {
             tests::{BaseField, TestFixedBases},
             FixedPointBaseField, NonIdentityPoint, Point,
         },
-        utilities::UtilitiesInstructions,
+        utilities::{lookup_range_check::PallasLookupRangeCheck, UtilitiesInstructions},
     };
 
-    pub(crate) fn test_mul_fixed_base_field(
-        chip: EccChip<TestFixedBases>,
+    pub(crate) fn test_mul_fixed_base_field<Lookup: PallasLookupRangeCheck>(
+        chip: EccChip<TestFixedBases, Lookup>,
         mut layouter: impl Layouter<pallas::Base>,
     ) -> Result<(), Error> {
         test_single_base(
@@ -410,22 +413,22 @@ pub mod tests {
     }
 
     #[allow(clippy::op_ref)]
-    fn test_single_base(
-        chip: EccChip<TestFixedBases>,
+    fn test_single_base<Lookup: PallasLookupRangeCheck>(
+        chip: EccChip<TestFixedBases, Lookup>,
         mut layouter: impl Layouter<pallas::Base>,
-        base: FixedPointBaseField<pallas::Affine, EccChip<TestFixedBases>>,
+        base: FixedPointBaseField<pallas::Affine, EccChip<TestFixedBases, Lookup>>,
         base_val: pallas::Affine,
     ) -> Result<(), Error> {
         let rng = OsRng;
 
         let column = chip.config().advices[0];
 
-        fn constrain_equal_non_id(
-            chip: EccChip<TestFixedBases>,
+        fn constrain_equal_non_id<Lookup: PallasLookupRangeCheck>(
+            chip: EccChip<TestFixedBases, Lookup>,
             mut layouter: impl Layouter<pallas::Base>,
             base_val: pallas::Affine,
             scalar_val: pallas::Base,
-            result: Point<pallas::Affine, EccChip<TestFixedBases>>,
+            result: Point<pallas::Affine, EccChip<TestFixedBases, Lookup>>,
         ) -> Result<(), Error> {
             // Move scalar from base field into scalar field (which always fits for Pallas).
             let scalar = pallas::Scalar::from_repr(scalar_val.to_repr()).unwrap();
diff --git a/halo2_gadgets/src/ecc/chip/mul_fixed/full_width.rs b/halo2_gadgets/src/ecc/chip/mul_fixed/full_width.rs
index 886f86bbba..393f065206 100644
--- a/halo2_gadgets/src/ecc/chip/mul_fixed/full_width.rs
+++ b/halo2_gadgets/src/ecc/chip/mul_fixed/full_width.rs
@@ -187,14 +187,17 @@ pub mod tests {
     use pasta_curves::pallas;
     use rand::rngs::OsRng;
 
-    use crate::ecc::{
-        chip::{EccChip, FixedPoint as _, H},
-        tests::{FullWidth, TestFixedBases},
-        FixedPoint, NonIdentityPoint, Point, ScalarFixed,
+    use crate::{
+        ecc::{
+            chip::{EccChip, FixedPoint as _, H},
+            tests::{FullWidth, TestFixedBases},
+            FixedPoint, NonIdentityPoint, Point, ScalarFixed,
+        },
+        utilities::lookup_range_check::PallasLookupRangeCheck,
     };
 
-    pub(crate) fn test_mul_fixed(
-        chip: EccChip<TestFixedBases>,
+    pub(crate) fn test_mul_fixed<Lookup: PallasLookupRangeCheck>(
+        chip: EccChip<TestFixedBases, Lookup>,
         mut layouter: impl Layouter<pallas::Base>,
     ) -> Result<(), Error> {
         let test_base = FullWidth::from_pallas_generator();
@@ -209,18 +212,18 @@ pub mod tests {
     }
 
     #[allow(clippy::op_ref)]
-    fn test_single_base(
-        chip: EccChip<TestFixedBases>,
+    fn test_single_base<Lookup: PallasLookupRangeCheck>(
+        chip: EccChip<TestFixedBases, Lookup>,
         mut layouter: impl Layouter<pallas::Base>,
-        base: FixedPoint<pallas::Affine, EccChip<TestFixedBases>>,
+        base: FixedPoint<pallas::Affine, EccChip<TestFixedBases, Lookup>>,
         base_val: pallas::Affine,
     ) -> Result<(), Error> {
-        fn constrain_equal_non_id(
-            chip: EccChip<TestFixedBases>,
+        fn constrain_equal_non_id<Lookup: PallasLookupRangeCheck>(
+            chip: EccChip<TestFixedBases, Lookup>,
             mut layouter: impl Layouter<pallas::Base>,
             base_val: pallas::Affine,
             scalar_val: pallas::Scalar,
-            result: Point<pallas::Affine, EccChip<TestFixedBases>>,
+            result: Point<pallas::Affine, EccChip<TestFixedBases, Lookup>>,
         ) -> Result<(), Error> {
             let expected = NonIdentityPoint::new(
                 chip,
diff --git a/halo2_gadgets/src/ecc/chip/mul_fixed/short.rs b/halo2_gadgets/src/ecc/chip/mul_fixed/short.rs
index bfdc735f70..ac5d57214f 100644
--- a/halo2_gadgets/src/ecc/chip/mul_fixed/short.rs
+++ b/halo2_gadgets/src/ecc/chip/mul_fixed/short.rs
@@ -248,31 +248,36 @@ pub mod tests {
     use group::{ff::PrimeField, Curve};
     use halo2_proofs::{
         arithmetic::CurveAffine,
-        circuit::{AssignedCell, Chip, Layouter, Value},
-        plonk::{Any, Error},
+        circuit::{AssignedCell, Chip, Layouter, SimpleFloorPlanner, Value},
+        dev::{FailureLocation, MockProver, VerifyFailure},
+        plonk::{Any, Circuit, ConstraintSystem, Error},
     };
     use pasta_curves::pallas;
+    use std::marker::PhantomData;
 
     use crate::{
         ecc::{
-            chip::{EccChip, FixedPoint, MagnitudeSign},
+            chip::{EccChip, EccConfig, FixedPoint, MagnitudeSign},
             tests::{Short, TestFixedBases},
             FixedPointShort, NonIdentityPoint, Point, ScalarFixedShort,
         },
-        utilities::{lookup_range_check::LookupRangeCheckConfig, UtilitiesInstructions},
+        utilities::{
+            lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
+            UtilitiesInstructions,
+        },
     };
 
     #[allow(clippy::op_ref)]
-    pub(crate) fn test_mul_fixed_short(
-        chip: EccChip<TestFixedBases>,
+    pub(crate) fn test_mul_fixed_short<Lookup: PallasLookupRangeCheck>(
+        chip: EccChip<TestFixedBases, Lookup>,
         mut layouter: impl Layouter<pallas::Base>,
     ) -> Result<(), Error> {
         // test_short
         let base_val = Short.generator();
         let test_short = FixedPointShort::from_inner(chip.clone(), Short);
 
-        fn load_magnitude_sign(
-            chip: EccChip<TestFixedBases>,
+        fn load_magnitude_sign<Lookup: PallasLookupRangeCheck>(
+            chip: EccChip<TestFixedBases, Lookup>,
             mut layouter: impl Layouter<pallas::Base>,
             magnitude: pallas::Base,
             sign: pallas::Base,
@@ -289,12 +294,12 @@ pub mod tests {
             Ok((magnitude, sign))
         }
 
-        fn constrain_equal_non_id(
-            chip: EccChip<TestFixedBases>,
+        fn constrain_equal_non_id<Lookup: PallasLookupRangeCheck>(
+            chip: EccChip<TestFixedBases, Lookup>,
             mut layouter: impl Layouter<pallas::Base>,
             base_val: pallas::Affine,
             scalar_val: pallas::Scalar,
-            result: Point<pallas::Affine, EccChip<TestFixedBases>>,
+            result: Point<pallas::Affine, EccChip<TestFixedBases, Lookup>>,
         ) -> Result<(), Error> {
             let expected = NonIdentityPoint::new(
                 chip,
@@ -400,261 +405,280 @@ pub mod tests {
         Ok(())
     }
 
-    #[test]
-    fn invalid_magnitude_sign() {
-        use crate::{
-            ecc::chip::{EccConfig, FixedPoint},
-            utilities::UtilitiesInstructions,
-        };
-        use halo2_proofs::{
-            circuit::{Layouter, SimpleFloorPlanner},
-            dev::{FailureLocation, MockProver, VerifyFailure},
-            plonk::{Circuit, ConstraintSystem, Error},
-        };
-
-        #[derive(Default)]
-        struct MyCircuit {
-            magnitude: Value<pallas::Base>,
-            sign: Value<pallas::Base>,
-            // For test checking
-            magnitude_error: Value<pallas::Base>,
-        }
+    #[derive(Default)]
+    struct MyMagnitudeSignCircuit<Lookup: PallasLookupRangeCheck> {
+        magnitude: Value<pallas::Base>,
+        sign: Value<pallas::Base>,
+        // For test checking
+        magnitude_error: Value<pallas::Base>,
+        _lookup_marker: PhantomData<Lookup>,
+    }
 
-        impl UtilitiesInstructions<pallas::Base> for MyCircuit {
-            type Var = AssignedCell<pallas::Base, pallas::Base>;
-        }
+    impl<Lookup: PallasLookupRangeCheck> UtilitiesInstructions<pallas::Base>
+        for MyMagnitudeSignCircuit<Lookup>
+    {
+        type Var = AssignedCell<pallas::Base, pallas::Base>;
+    }
 
-        impl Circuit<pallas::Base> for MyCircuit {
-            type Config = EccConfig<TestFixedBases>;
-            type FloorPlanner = SimpleFloorPlanner;
+    impl<Lookup: PallasLookupRangeCheck> Circuit<pallas::Base> for MyMagnitudeSignCircuit<Lookup> {
+        type Config = EccConfig<TestFixedBases, Lookup>;
+        type FloorPlanner = SimpleFloorPlanner;
 
-            fn without_witnesses(&self) -> Self {
-                Self::default()
+        fn without_witnesses(&self) -> Self {
+            MyMagnitudeSignCircuit {
+                magnitude: Value::unknown(),
+                sign: Value::unknown(),
+                magnitude_error: Value::unknown(),
+                _lookup_marker: PhantomData,
             }
+        }
 
-            fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
-                let advices = [
-                    meta.advice_column(),
-                    meta.advice_column(),
-                    meta.advice_column(),
-                    meta.advice_column(),
-                    meta.advice_column(),
-                    meta.advice_column(),
-                    meta.advice_column(),
-                    meta.advice_column(),
-                    meta.advice_column(),
-                    meta.advice_column(),
-                ];
-                let lookup_table = meta.lookup_table_column();
-                let lagrange_coeffs = [
-                    meta.fixed_column(),
-                    meta.fixed_column(),
-                    meta.fixed_column(),
-                    meta.fixed_column(),
-                    meta.fixed_column(),
-                    meta.fixed_column(),
-                    meta.fixed_column(),
-                    meta.fixed_column(),
-                ];
+        fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
+            let advices = [
+                meta.advice_column(),
+                meta.advice_column(),
+                meta.advice_column(),
+                meta.advice_column(),
+                meta.advice_column(),
+                meta.advice_column(),
+                meta.advice_column(),
+                meta.advice_column(),
+                meta.advice_column(),
+                meta.advice_column(),
+            ];
+            let lookup_table = meta.lookup_table_column();
+            let lagrange_coeffs = [
+                meta.fixed_column(),
+                meta.fixed_column(),
+                meta.fixed_column(),
+                meta.fixed_column(),
+                meta.fixed_column(),
+                meta.fixed_column(),
+                meta.fixed_column(),
+                meta.fixed_column(),
+            ];
 
-                // Shared fixed column for loading constants
-                let constants = meta.fixed_column();
-                meta.enable_constant(constants);
+            // Shared fixed column for loading constants
+            let constants = meta.fixed_column();
+            meta.enable_constant(constants);
 
-                let range_check = LookupRangeCheckConfig::configure(meta, advices[9], lookup_table);
-                EccChip::<TestFixedBases>::configure(meta, advices, lagrange_coeffs, range_check)
-            }
+            let range_check = Lookup::configure(meta, advices[9], lookup_table);
+            EccChip::<TestFixedBases, Lookup>::configure(
+                meta,
+                advices,
+                lagrange_coeffs,
+                range_check,
+            )
+        }
 
-            fn synthesize(
-                &self,
-                config: Self::Config,
-                mut layouter: impl Layouter<pallas::Base>,
-            ) -> Result<(), Error> {
-                let column = config.advices[0];
-
-                let short_config = config.mul_fixed_short.clone();
-                let magnitude_sign = {
-                    let magnitude = self.load_private(
-                        layouter.namespace(|| "load magnitude"),
-                        column,
-                        self.magnitude,
-                    )?;
-                    let sign =
-                        self.load_private(layouter.namespace(|| "load sign"), column, self.sign)?;
-                    ScalarFixedShort::new(
-                        EccChip::construct(config),
-                        layouter.namespace(|| "signed short scalar"),
-                        (magnitude, sign),
-                    )?
-                };
+        fn synthesize(
+            &self,
+            config: Self::Config,
+            mut layouter: impl Layouter<pallas::Base>,
+        ) -> Result<(), Error> {
+            let column = config.advices[0];
+
+            let short_config = config.mul_fixed_short.clone();
+            let magnitude_sign = {
+                let magnitude = self.load_private(
+                    layouter.namespace(|| "load magnitude"),
+                    column,
+                    self.magnitude,
+                )?;
+                let sign =
+                    self.load_private(layouter.namespace(|| "load sign"), column, self.sign)?;
+                ScalarFixedShort::new(
+                    EccChip::construct(config),
+                    layouter.namespace(|| "signed short scalar"),
+                    (magnitude, sign),
+                )?
+            };
 
-                short_config.assign(layouter, &magnitude_sign.inner, &Short)?;
+            short_config.assign(layouter, &magnitude_sign.inner, &Short)?;
 
-                Ok(())
-            }
+            Ok(())
         }
+    }
 
-        // Copied from halo2_proofs::dev::util
-        fn format_value(v: pallas::Base) -> String {
-            use ff::Field;
-            if v.is_zero_vartime() {
-                "0".into()
-            } else if v == pallas::Base::one() {
-                "1".into()
-            } else if v == -pallas::Base::one() {
-                "-1".into()
-            } else {
-                // Format value as hex.
-                let s = format!("{:?}", v);
-                // Remove leading zeroes.
-                let s = s.strip_prefix("0x").unwrap();
-                let s = s.trim_start_matches('0');
-                format!("0x{}", s)
-            }
+    // Copied from halo2_proofs::dev::util
+    fn format_value(v: pallas::Base) -> String {
+        use ff::Field;
+        if v.is_zero_vartime() {
+            "0".into()
+        } else if v == pallas::Base::one() {
+            "1".into()
+        } else if v == -pallas::Base::one() {
+            "-1".into()
+        } else {
+            // Format value as hex.
+            let s = format!("{:?}", v);
+            // Remove leading zeroes.
+            let s = s.strip_prefix("0x").unwrap();
+            let s = s.trim_start_matches('0');
+            format!("0x{}", s)
         }
+    }
 
-        // Magnitude larger than 64 bits should fail
-        {
-            let circuits = [
-                // 2^64
-                MyCircuit {
-                    magnitude: Value::known(pallas::Base::from_u128(1 << 64)),
-                    sign: Value::known(pallas::Base::one()),
-                    magnitude_error: Value::known(pallas::Base::from(1 << 1)),
-                },
-                // -2^64
-                MyCircuit {
-                    magnitude: Value::known(pallas::Base::from_u128(1 << 64)),
-                    sign: Value::known(-pallas::Base::one()),
-                    magnitude_error: Value::known(pallas::Base::from(1 << 1)),
-                },
-                // 2^66
-                MyCircuit {
-                    magnitude: Value::known(pallas::Base::from_u128(1 << 66)),
-                    sign: Value::known(pallas::Base::one()),
-                    magnitude_error: Value::known(pallas::Base::from(1 << 3)),
-                },
-                // -2^66
-                MyCircuit {
-                    magnitude: Value::known(pallas::Base::from_u128(1 << 66)),
-                    sign: Value::known(-pallas::Base::one()),
-                    magnitude_error: Value::known(pallas::Base::from(1 << 3)),
-                },
-                // 2^254
-                MyCircuit {
-                    magnitude: Value::known(pallas::Base::from_u128(1 << 127).square()),
-                    sign: Value::known(pallas::Base::one()),
-                    magnitude_error: Value::known(
-                        pallas::Base::from_u128(1 << 95).square() * pallas::Base::from(2),
-                    ),
-                },
-                // -2^254
-                MyCircuit {
-                    magnitude: Value::known(pallas::Base::from_u128(1 << 127).square()),
-                    sign: Value::known(-pallas::Base::one()),
-                    magnitude_error: Value::known(
-                        pallas::Base::from_u128(1 << 95).square() * pallas::Base::from(2),
-                    ),
-                },
-            ];
+    impl<Lookup: PallasLookupRangeCheck> MyMagnitudeSignCircuit<Lookup> {
+        fn test_invalid_magnitude_sign() {
+            // Magnitude larger than 64 bits should fail
+            {
+                let circuits = [
+                    // 2^64
+                    MyMagnitudeSignCircuit::<Lookup> {
+                        magnitude: Value::known(pallas::Base::from_u128(1 << 64)),
+                        sign: Value::known(pallas::Base::one()),
+                        magnitude_error: Value::known(pallas::Base::from(1 << 1)),
+                        _lookup_marker: PhantomData,
+                    },
+                    // -2^64
+                    MyMagnitudeSignCircuit::<Lookup> {
+                        magnitude: Value::known(pallas::Base::from_u128(1 << 64)),
+                        sign: Value::known(-pallas::Base::one()),
+                        magnitude_error: Value::known(pallas::Base::from(1 << 1)),
+                        _lookup_marker: PhantomData,
+                    },
+                    // 2^66
+                    MyMagnitudeSignCircuit::<Lookup> {
+                        magnitude: Value::known(pallas::Base::from_u128(1 << 66)),
+                        sign: Value::known(pallas::Base::one()),
+                        magnitude_error: Value::known(pallas::Base::from(1 << 3)),
+                        _lookup_marker: PhantomData,
+                    },
+                    // -2^66
+                    MyMagnitudeSignCircuit::<Lookup> {
+                        magnitude: Value::known(pallas::Base::from_u128(1 << 66)),
+                        sign: Value::known(-pallas::Base::one()),
+                        magnitude_error: Value::known(pallas::Base::from(1 << 3)),
+                        _lookup_marker: PhantomData,
+                    },
+                    // 2^254
+                    MyMagnitudeSignCircuit::<Lookup> {
+                        magnitude: Value::known(pallas::Base::from_u128(1 << 127).square()),
+                        sign: Value::known(pallas::Base::one()),
+                        magnitude_error: Value::known(
+                            pallas::Base::from_u128(1 << 95).square() * pallas::Base::from(2),
+                        ),
+                        _lookup_marker: PhantomData,
+                    },
+                    // -2^254
+                    MyMagnitudeSignCircuit::<Lookup> {
+                        magnitude: Value::known(pallas::Base::from_u128(1 << 127).square()),
+                        sign: Value::known(-pallas::Base::one()),
+                        magnitude_error: Value::known(
+                            pallas::Base::from_u128(1 << 95).square() * pallas::Base::from(2),
+                        ),
+                        _lookup_marker: PhantomData,
+                    },
+                ];
 
-            for circuit in circuits.iter() {
-                let prover = MockProver::<pallas::Base>::run(11, circuit, vec![]).unwrap();
-                circuit.magnitude_error.assert_if_known(|magnitude_error| {
-                    assert_eq!(
-                        prover.verify(),
-                        Err(vec![
-                            VerifyFailure::ConstraintNotSatisfied {
-                                constraint: (
-                                    (17, "Short fixed-base mul gate").into(),
-                                    0,
-                                    "last_window_check",
-                                )
-                                    .into(),
-                                location: FailureLocation::InRegion {
-                                    region: (3, "Short fixed-base mul (most significant word)")
+                for circuit in circuits.iter() {
+                    let prover = MockProver::<pallas::Base>::run(11, circuit, vec![]).unwrap();
+                    circuit.magnitude_error.assert_if_known(|magnitude_error| {
+                        assert_eq!(
+                            prover.verify(),
+                            Err(vec![
+                                VerifyFailure::ConstraintNotSatisfied {
+                                    constraint: (
+                                        (17, "Short fixed-base mul gate").into(),
+                                        0,
+                                        "last_window_check",
+                                    )
                                         .into(),
-                                    offset: 1,
+                                    location: FailureLocation::InRegion {
+                                        region: (3, "Short fixed-base mul (most significant word)")
+                                            .into(),
+                                        offset: 1,
+                                    },
+                                    cell_values: vec![(
+                                        ((Any::Advice, 5).into(), 0).into(),
+                                        format_value(*magnitude_error),
+                                    )],
                                 },
-                                cell_values: vec![(
-                                    ((Any::Advice, 5).into(), 0).into(),
-                                    format_value(*magnitude_error),
-                                )],
-                            },
-                            VerifyFailure::Permutation {
-                                column: (Any::Fixed, 9).into(),
-                                location: FailureLocation::OutsideRegion { row: 0 },
-                            },
-                            VerifyFailure::Permutation {
-                                column: (Any::Advice, 4).into(),
-                                location: FailureLocation::InRegion {
-                                    region: (2, "Short fixed-base mul (incomplete addition)")
-                                        .into(),
-                                    offset: 22,
+                                VerifyFailure::Permutation {
+                                    column: (Any::Fixed, 9).into(),
+                                    location: FailureLocation::OutsideRegion { row: 0 },
                                 },
-                            },
-                        ])
-                    );
-                    true
-                });
+                                VerifyFailure::Permutation {
+                                    column: (Any::Advice, 4).into(),
+                                    location: FailureLocation::InRegion {
+                                        region: (2, "Short fixed-base mul (incomplete addition)")
+                                            .into(),
+                                        offset: 22,
+                                    },
+                                },
+                            ])
+                        );
+                        true
+                    });
+                }
             }
-        }
 
-        // Sign that is not +/- 1 should fail
-        {
-            let magnitude_u64 = rand::random::<u64>();
-            let circuit = MyCircuit {
-                magnitude: Value::known(pallas::Base::from(magnitude_u64)),
-                sign: Value::known(pallas::Base::zero()),
-                magnitude_error: Value::unknown(),
-            };
+            // Sign that is not +/- 1 should fail
+            {
+                let magnitude_u64 = rand::random::<u64>();
+                let circuit: MyMagnitudeSignCircuit<Lookup> = MyMagnitudeSignCircuit {
+                    magnitude: Value::known(pallas::Base::from(magnitude_u64)),
+                    sign: Value::known(pallas::Base::zero()),
+                    magnitude_error: Value::unknown(),
+                    _lookup_marker: PhantomData,
+                };
 
-            let negation_check_y = {
-                *(Short.generator() * pallas::Scalar::from(magnitude_u64))
-                    .to_affine()
-                    .coordinates()
-                    .unwrap()
-                    .y()
-            };
+                let negation_check_y = {
+                    *(Short.generator() * pallas::Scalar::from(magnitude_u64))
+                        .to_affine()
+                        .coordinates()
+                        .unwrap()
+                        .y()
+                };
 
-            let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
-            assert_eq!(
-                prover.verify(),
-                Err(vec![
-                    VerifyFailure::ConstraintNotSatisfied {
-                        constraint: ((17, "Short fixed-base mul gate").into(), 1, "sign_check")
-                            .into(),
-                        location: FailureLocation::InRegion {
-                            region: (3, "Short fixed-base mul (most significant word)").into(),
-                            offset: 1,
-                        },
-                        cell_values: vec![(((Any::Advice, 4).into(), 0).into(), "0".to_string())],
-                    },
-                    VerifyFailure::ConstraintNotSatisfied {
-                        constraint: (
-                            (17, "Short fixed-base mul gate").into(),
-                            3,
-                            "negation_check"
-                        )
-                            .into(),
-                        location: FailureLocation::InRegion {
-                            region: (3, "Short fixed-base mul (most significant word)").into(),
-                            offset: 1,
+                let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
+                assert_eq!(
+                    prover.verify(),
+                    Err(vec![
+                        VerifyFailure::ConstraintNotSatisfied {
+                            constraint: ((17, "Short fixed-base mul gate").into(), 1, "sign_check")
+                                .into(),
+                            location: FailureLocation::InRegion {
+                                region: (3, "Short fixed-base mul (most significant word)").into(),
+                                offset: 1,
+                            },
+                            cell_values: vec![(
+                                ((Any::Advice, 4).into(), 0).into(),
+                                "0".to_string()
+                            )],
                         },
-                        cell_values: vec![
-                            (
-                                ((Any::Advice, 1).into(), 0).into(),
-                                format_value(negation_check_y),
-                            ),
-                            (
-                                ((Any::Advice, 3).into(), 0).into(),
-                                format_value(negation_check_y),
-                            ),
-                            (((Any::Advice, 4).into(), 0).into(), "0".to_string()),
-                        ],
-                    }
-                ])
-            );
+                        VerifyFailure::ConstraintNotSatisfied {
+                            constraint: (
+                                (17, "Short fixed-base mul gate").into(),
+                                3,
+                                "negation_check"
+                            )
+                                .into(),
+                            location: FailureLocation::InRegion {
+                                region: (3, "Short fixed-base mul (most significant word)").into(),
+                                offset: 1,
+                            },
+                            cell_values: vec![
+                                (
+                                    ((Any::Advice, 1).into(), 0).into(),
+                                    format_value(negation_check_y),
+                                ),
+                                (
+                                    ((Any::Advice, 3).into(), 0).into(),
+                                    format_value(negation_check_y),
+                                ),
+                                (((Any::Advice, 4).into(), 0).into(), "0".to_string()),
+                            ],
+                        }
+                    ])
+                );
+            }
         }
     }
+
+    #[test]
+    fn invalid_magnitude_sign() {
+        MyMagnitudeSignCircuit::<PallasLookupRangeCheckConfig>::test_invalid_magnitude_sign();
+    }
 }
diff --git a/halo2_gadgets/src/lib.rs b/halo2_gadgets/src/lib.rs
index 2ac2623a99..cef325c385 100644
--- a/halo2_gadgets/src/lib.rs
+++ b/halo2_gadgets/src/lib.rs
@@ -28,3 +28,6 @@ pub mod poseidon;
 pub mod sha256;
 pub mod sinsemilla;
 pub mod utilities;
+
+#[cfg(test)]
+pub mod tests;
diff --git a/halo2_gadgets/src/sinsemilla.rs b/halo2_gadgets/src/sinsemilla.rs
index 3f06315a77..c576fda455 100644
--- a/halo2_gadgets/src/sinsemilla.rs
+++ b/halo2_gadgets/src/sinsemilla.rs
@@ -466,16 +466,14 @@ pub(crate) mod tests {
     };
 
     use crate::{
-        ecc::ScalarFixed,
-        sinsemilla::primitives::{self as sinsemilla, K},
-        {
-            ecc::{
-                chip::{find_zs_and_us, EccChip, EccConfig, H, NUM_WINDOWS},
-                tests::{FullWidth, TestFixedBases},
-                NonIdentityPoint,
-            },
-            utilities::lookup_range_check::LookupRangeCheckConfig,
+        ecc::{
+            chip::{find_zs_and_us, EccChip, EccConfig, H, NUM_WINDOWS},
+            tests::{FullWidth, TestFixedBases},
+            NonIdentityPoint, ScalarFixed,
         },
+        sinsemilla::primitives::{self as sinsemilla, K},
+        tests::test_utils::test_against_stored_circuit,
+        utilities::lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
     };
 
     use group::{ff::Field, Curve};
@@ -483,6 +481,7 @@ pub(crate) mod tests {
     use pasta_curves::pallas;
 
     use std::convert::TryInto;
+    use std::marker::PhantomData;
 
     pub(crate) const PERSONALIZATION: &str = "MerkleCRH";
 
@@ -516,19 +515,31 @@ pub(crate) mod tests {
         }
     }
 
-    struct MyCircuit {}
+    struct MyCircuit<Lookup: PallasLookupRangeCheck> {
+        _lookup_marker: PhantomData<Lookup>,
+    }
+
+    impl<Lookup: PallasLookupRangeCheck> MyCircuit<Lookup> {
+        fn new() -> Self {
+            MyCircuit {
+                _lookup_marker: PhantomData,
+            }
+        }
+    }
+
+    type MyConfig<Lookup> = (
+        EccConfig<TestFixedBases, Lookup>,
+        SinsemillaConfig<TestHashDomain, TestCommitDomain, TestFixedBases, Lookup>,
+        SinsemillaConfig<TestHashDomain, TestCommitDomain, TestFixedBases, Lookup>,
+    );
 
-    impl Circuit<pallas::Base> for MyCircuit {
+    impl<Lookup: PallasLookupRangeCheck> Circuit<pallas::Base> for MyCircuit<Lookup> {
         #[allow(clippy::type_complexity)]
-        type Config = (
-            EccConfig<TestFixedBases>,
-            SinsemillaConfig<TestHashDomain, TestCommitDomain, TestFixedBases>,
-            SinsemillaConfig<TestHashDomain, TestCommitDomain, TestFixedBases>,
-        );
+        type Config = MyConfig<Lookup>;
         type FloorPlanner = SimpleFloorPlanner;
 
         fn without_witnesses(&self) -> Self {
-            MyCircuit {}
+            MyCircuit::new()
         }
 
         #[allow(non_snake_case)]
@@ -569,10 +580,14 @@ pub(crate) mod tests {
                 meta.lookup_table_column(),
             );
 
-            let range_check = LookupRangeCheckConfig::configure(meta, advices[9], table_idx);
+            let range_check = Lookup::configure(meta, advices[9], table_idx);
 
-            let ecc_config =
-                EccChip::<TestFixedBases>::configure(meta, advices, lagrange_coeffs, range_check);
+            let ecc_config = EccChip::<TestFixedBases, Lookup>::configure(
+                meta,
+                advices,
+                lagrange_coeffs,
+                range_check,
+            );
 
             let config1 = SinsemillaChip::configure(
                 meta,
@@ -603,7 +618,7 @@ pub(crate) mod tests {
             let ecc_chip = EccChip::construct(config.0);
 
             // The two `SinsemillaChip`s share the same lookup table.
-            SinsemillaChip::<TestHashDomain, TestCommitDomain, TestFixedBases>::load(
+            SinsemillaChip::<TestHashDomain, TestCommitDomain, TestFixedBases, Lookup>::load(
                 config.1.clone(),
                 &mut layouter,
             )?;
@@ -733,11 +748,17 @@ pub(crate) mod tests {
     #[test]
     fn sinsemilla_chip() {
         let k = 11;
-        let circuit = MyCircuit {};
+        let circuit = MyCircuit::<PallasLookupRangeCheckConfig>::new();
         let prover = MockProver::run(k, &circuit, vec![]).unwrap();
         assert_eq!(prover.verify(), Ok(()))
     }
 
+    #[test]
+    fn test_sinsemilla_chip_against_stored_circuit() {
+        let circuit = MyCircuit::<PallasLookupRangeCheckConfig>::new();
+        test_against_stored_circuit(circuit, "sinsemilla_chip", 4576);
+    }
+
     #[cfg(feature = "test-dev-graph")]
     #[test]
     fn print_sinsemilla_chip() {
@@ -748,7 +769,7 @@ pub(crate) mod tests {
         root.fill(&WHITE).unwrap();
         let root = root.titled("SinsemillaHash", ("sans-serif", 60)).unwrap();
 
-        let circuit = MyCircuit {};
+        let circuit = MyCircuit::<PallasLookupRangeCheckConfig>::new();
         halo2_proofs::dev::CircuitLayout::default()
             .render(11, &circuit, &root)
             .unwrap();
diff --git a/halo2_gadgets/src/sinsemilla/chip.rs b/halo2_gadgets/src/sinsemilla/chip.rs
index ac4c34f781..19f86a6b7d 100644
--- a/halo2_gadgets/src/sinsemilla/chip.rs
+++ b/halo2_gadgets/src/sinsemilla/chip.rs
@@ -9,7 +9,7 @@ use crate::{
         chip::{DoubleAndAdd, NonIdentityEccPoint},
         FixedPoints,
     },
-    utilities::lookup_range_check::LookupRangeCheckConfig,
+    utilities::lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
 };
 use std::marker::PhantomData;
 
@@ -30,11 +30,12 @@ mod hash_to_point;
 
 /// Configuration for the Sinsemilla hash chip
 #[derive(Eq, PartialEq, Clone, Debug)]
-pub struct SinsemillaConfig<Hash, Commit, F>
+pub struct SinsemillaConfig<Hash, Commit, F, Lookup = PallasLookupRangeCheckConfig>
 where
     Hash: HashDomains<pallas::Affine>,
     F: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, F, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
     /// Binary selector used in lookup argument and in the body of the Sinsemilla hash.
     q_sinsemilla1: Selector,
@@ -58,15 +59,16 @@ where
     /// generators of the Sinsemilla hash.
     pub(super) generator_table: GeneratorTableConfig,
     /// An advice column configured to perform lookup range checks.
-    lookup_config: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
+    lookup_config: Lookup,
     _marker: PhantomData<(Hash, Commit, F)>,
 }
 
-impl<Hash, Commit, F> SinsemillaConfig<Hash, Commit, F>
+impl<Hash, Commit, F, Lookup> SinsemillaConfig<Hash, Commit, F, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     F: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, F, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
     /// Returns an array of all advice columns in this config, in arbitrary order.
     pub(super) fn advices(&self) -> [Column<Advice>; 5] {
@@ -80,7 +82,7 @@ where
     }
 
     /// Returns the lookup range check config used in this config.
-    pub fn lookup_config(&self) -> LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }> {
+    pub fn lookup_config(&self) -> Lookup {
         self.lookup_config
     }
 
@@ -96,22 +98,24 @@ where
 ///
 /// [Chip description](https://zcash.github.io/halo2/design/gadgets/sinsemilla.html#plonk--halo-2-constraints).
 #[derive(Eq, PartialEq, Clone, Debug)]
-pub struct SinsemillaChip<Hash, Commit, Fixed>
+pub struct SinsemillaChip<Hash, Commit, Fixed, Lookup = PallasLookupRangeCheckConfig>
 where
     Hash: HashDomains<pallas::Affine>,
     Fixed: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, Fixed, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
-    config: SinsemillaConfig<Hash, Commit, Fixed>,
+    config: SinsemillaConfig<Hash, Commit, Fixed, Lookup>,
 }
 
-impl<Hash, Commit, Fixed> Chip<pallas::Base> for SinsemillaChip<Hash, Commit, Fixed>
+impl<Hash, Commit, Fixed, Lookup> Chip<pallas::Base> for SinsemillaChip<Hash, Commit, Fixed, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     Fixed: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, Fixed, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
-    type Config = SinsemillaConfig<Hash, Commit, Fixed>;
+    type Config = SinsemillaConfig<Hash, Commit, Fixed, Lookup>;
     type Loaded = ();
 
     fn config(&self) -> &Self::Config {
@@ -123,11 +127,12 @@ where
     }
 }
 
-impl<Hash, Commit, F> SinsemillaChip<Hash, Commit, F>
+impl<Hash, Commit, F, Lookup> SinsemillaChip<Hash, Commit, F, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     F: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, F, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
     /// Reconstructs this chip from the given config.
     pub fn construct(config: <Self as Chip<pallas::Base>>::Config) -> Self {
@@ -136,10 +141,11 @@ where
 
     /// Loads the lookup table required by this chip into the circuit.
     pub fn load(
-        config: SinsemillaConfig<Hash, Commit, F>,
+        config: SinsemillaConfig<Hash, Commit, F, Lookup>,
         layouter: &mut impl Layouter<pallas::Base>,
     ) -> Result<<Self as Chip<pallas::Base>>::Loaded, Error> {
         // Load the lookup table.
+
         config.generator_table.load(layouter)
     }
 
@@ -154,14 +160,14 @@ where
         witness_pieces: Column<Advice>,
         fixed_y_q: Column<Fixed>,
         lookup: (TableColumn, TableColumn, TableColumn),
-        range_check: LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>,
+        range_check: Lookup,
     ) -> <Self as Chip<pallas::Base>>::Config {
         // Enable equality on all advice columns
         for advice in advices.iter() {
             meta.enable_equality(*advice);
         }
 
-        let config = SinsemillaConfig::<Hash, Commit, F> {
+        let config = SinsemillaConfig::<Hash, Commit, F, Lookup> {
             q_sinsemilla1: meta.complex_selector(),
             q_sinsemilla2: meta.fixed_column(),
             q_sinsemilla4: meta.selector(),
@@ -264,12 +270,14 @@ where
 }
 
 // Implement `SinsemillaInstructions` for `SinsemillaChip`
-impl<Hash, Commit, F> SinsemillaInstructions<pallas::Affine, { sinsemilla::K }, { sinsemilla::C }>
-    for SinsemillaChip<Hash, Commit, F>
+impl<Hash, Commit, F, Lookup>
+    SinsemillaInstructions<pallas::Affine, { sinsemilla::K }, { sinsemilla::C }>
+    for SinsemillaChip<Hash, Commit, F, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     F: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, F, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
     type CellValue = AssignedCell<pallas::Base, pallas::Base>;
 
diff --git a/halo2_gadgets/src/sinsemilla/chip/generator_table.rs b/halo2_gadgets/src/sinsemilla/chip/generator_table.rs
index fd0ff03f91..96219016b2 100644
--- a/halo2_gadgets/src/sinsemilla/chip/generator_table.rs
+++ b/halo2_gadgets/src/sinsemilla/chip/generator_table.rs
@@ -6,7 +6,10 @@ use halo2_proofs::{
 };
 
 use super::{CommitDomains, FixedPoints, HashDomains};
-use crate::sinsemilla::primitives::{self as sinsemilla, SINSEMILLA_S};
+use crate::{
+    sinsemilla::primitives::{self as sinsemilla, SINSEMILLA_S},
+    utilities::lookup_range_check::PallasLookupRangeCheck,
+};
 use pasta_curves::pallas;
 
 /// Table containing independent generators S[0..2^k]
@@ -23,13 +26,14 @@ impl GeneratorTableConfig {
     /// Even though the lookup table can be used in other parts of the circuit,
     /// this specific configuration sets up Sinsemilla-specific constraints
     /// controlled by `q_sinsemilla`, and would likely not apply to other chips.
-    pub fn configure<Hash, Commit, F>(
+    pub fn configure<Hash, Commit, F, Lookup>(
         meta: &mut ConstraintSystem<pallas::Base>,
-        config: super::SinsemillaConfig<Hash, Commit, F>,
+        config: super::SinsemillaConfig<Hash, Commit, F, Lookup>,
     ) where
         Hash: HashDomains<pallas::Affine>,
         F: FixedPoints<pallas::Affine>,
         Commit: CommitDomains<pallas::Affine, F, Hash>,
+        Lookup: PallasLookupRangeCheck,
     {
         let (table_idx, table_x, table_y) = (
             config.generator_table.table_idx,
diff --git a/halo2_gadgets/src/sinsemilla/chip/hash_to_point.rs b/halo2_gadgets/src/sinsemilla/chip/hash_to_point.rs
index 44beaa4259..f7a4ba2686 100644
--- a/halo2_gadgets/src/sinsemilla/chip/hash_to_point.rs
+++ b/halo2_gadgets/src/sinsemilla/chip/hash_to_point.rs
@@ -3,6 +3,7 @@ use super::{NonIdentityEccPoint, SinsemillaChip};
 use crate::{
     ecc::FixedPoints,
     sinsemilla::primitives::{self as sinsemilla, lebs2ip_k, INV_TWO_POW_K, SINSEMILLA_S},
+    utilities::lookup_range_check::PallasLookupRangeCheck,
 };
 
 use ff::Field;
@@ -16,11 +17,21 @@ use pasta_curves::{arithmetic::CurveAffine, pallas};
 
 use std::ops::Deref;
 
-impl<Hash, Commit, Fixed> SinsemillaChip<Hash, Commit, Fixed>
+/// `EccPointQ` can hold either a public or a private ECC Point
+#[derive(Debug, Clone)]
+pub enum EccPointQ<'a> {
+    PublicPoint(pallas::Affine),
+    #[allow(dead_code)]
+    // We will use private point for ZSA
+    PrivatePoint(&'a NonIdentityEccPoint),
+}
+
+impl<Hash, Commit, Fixed, Lookup> SinsemillaChip<Hash, Commit, Fixed, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     Fixed: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, Fixed, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
     /// [Specification](https://p.z.cash/halo2-0.1:sinsemilla-constraints?partial).
     #[allow(non_snake_case)]
@@ -41,8 +52,28 @@ where
         ),
         Error,
     > {
+        let (offset, x_a, y_a) = self.public_q_initialization(region, Q)?;
+
+        let (x_a, y_a, zs_sum) = self.hash_all_pieces(region, offset, message, x_a, y_a)?;
+
+        self.check_hash_result(EccPointQ::PublicPoint(Q), message, x_a, y_a, zs_sum)
+    }
+
+    #[allow(non_snake_case)]
+    /// Assign the coordinates of the initial public point `Q`
+    /// - `x_Q` in a advice column, and
+    /// - `y_Q` in a fixed column.
+    ///
+    /// | offset | x_A | q_sinsemilla4 | fixed_y_q |
+    /// --------------------------------------
+    /// |   0    | x_Q |   1           |   y_Q     |
+    fn public_q_initialization(
+        &self,
+        region: &mut Region<'_, pallas::Base>,
+        Q: pallas::Affine,
+    ) -> Result<(usize, X<pallas::Base>, Y<pallas::Base>), Error> {
         let config = self.config().clone();
-        let mut offset = 0;
+        let offset = 0;
 
         // Get the `x`- and `y`-coordinates of the starting `Q` base.
         let x_q = *Q.coordinates().unwrap().x();
@@ -50,7 +81,7 @@ where
 
         // Constrain the initial x_a, lambda_1, lambda_2, x_p using the q_sinsemilla4
         // selector.
-        let mut y_a: Y<pallas::Base> = {
+        let y_a: Y<pallas::Base> = {
             // Enable `q_sinsemilla4` on the first row.
             config.q_sinsemilla4.enable(region, offset)?;
             region.assign_fixed(
@@ -64,7 +95,7 @@ where
         };
 
         // Constrain the initial x_q to equal the x-coordinate of the domain's `Q`.
-        let mut x_a: X<pallas::Base> = {
+        let x_a: X<pallas::Base> = {
             let x_a = region.assign_advice_from_constant(
                 || "fixed x_q",
                 config.double_and_add.x_a,
@@ -75,6 +106,32 @@ where
             x_a.into()
         };
 
+        Ok((offset, x_a, y_a))
+    }
+
+    #[allow(clippy::type_complexity)]
+    /// Hash `message` from the initial point `Q`.
+    fn hash_all_pieces(
+        &self,
+        region: &mut Region<'_, pallas::Base>,
+        mut offset: usize,
+        message: &<Self as SinsemillaInstructions<
+            pallas::Affine,
+            { sinsemilla::K },
+            { sinsemilla::C },
+        >>::Message,
+        mut x_a: X<pallas::Base>,
+        mut y_a: Y<pallas::Base>,
+    ) -> Result<
+        (
+            X<pallas::Base>,
+            AssignedCell<Assigned<pallas::Base>, pallas::Base>,
+            Vec<Vec<AssignedCell<pallas::Base, pallas::Base>>>,
+        ),
+        Error,
+    > {
+        let config = self.config().clone();
+
         let mut zs_sum: Vec<Vec<AssignedCell<pallas::Base, pallas::Base>>> = Vec::new();
 
         // Hash each piece in the message.
@@ -121,52 +178,7 @@ where
             y_a_cell
         };
 
-        #[cfg(test)]
-        #[allow(non_snake_case)]
-        // Check equivalence to result from primitives::sinsemilla::hash_to_point
-        {
-            use crate::sinsemilla::primitives::{K, S_PERSONALIZATION};
-
-            use group::{prime::PrimeCurveAffine, Curve};
-            use pasta_curves::arithmetic::CurveExt;
-
-            let field_elems: Value<Vec<_>> = message
-                .iter()
-                .map(|piece| piece.field_elem().map(|elem| (elem, piece.num_words())))
-                .collect();
-
-            field_elems
-                .zip(x_a.value().zip(y_a.value()))
-                .assert_if_known(|(field_elems, (x_a, y_a))| {
-                    // Get message as a bitstring.
-                    let bitstring: Vec<bool> = field_elems
-                        .iter()
-                        .flat_map(|(elem, num_words)| {
-                            elem.to_le_bits().into_iter().take(K * num_words)
-                        })
-                        .collect();
-
-                    let hasher_S = pallas::Point::hash_to_curve(S_PERSONALIZATION);
-                    let S = |chunk: &[bool]| hasher_S(&lebs2ip_k(chunk).to_le_bytes());
-
-                    // We can use complete addition here because it differs from
-                    // incomplete addition with negligible probability.
-                    let expected_point = bitstring
-                        .chunks(K)
-                        .fold(Q.to_curve(), |acc, chunk| (acc + S(chunk)) + acc);
-                    let actual_point =
-                        pallas::Affine::from_xy(x_a.evaluate(), y_a.evaluate()).unwrap();
-                    expected_point.to_affine() == actual_point
-                });
-        }
-
-        x_a.value()
-            .zip(y_a.value())
-            .error_if_known_and(|(x_a, y_a)| x_a.is_zero_vartime() || y_a.is_zero_vartime())?;
-        Ok((
-            NonIdentityEccPoint::from_coordinates_unchecked(x_a.0, y_a),
-            zs_sum,
-        ))
+        Ok((x_a, y_a, zs_sum))
     }
 
     #[allow(clippy::type_complexity)]
@@ -374,6 +386,79 @@ where
 
         Ok((x_a, y_a, zs))
     }
+    #[allow(unused_variables)]
+    #[allow(non_snake_case)]
+    #[allow(clippy::type_complexity)]
+    fn check_hash_result(
+        &self,
+        Q: EccPointQ,
+        message: &<Self as SinsemillaInstructions<
+            pallas::Affine,
+            { sinsemilla::K },
+            { sinsemilla::C },
+        >>::Message,
+        x_a: X<pallas::Base>,
+        y_a: AssignedCell<Assigned<pallas::Base>, pallas::Base>,
+        zs_sum: Vec<Vec<AssignedCell<pallas::Base, pallas::Base>>>,
+    ) -> Result<
+        (
+            NonIdentityEccPoint,
+            Vec<Vec<AssignedCell<pallas::Base, pallas::Base>>>,
+        ),
+        Error,
+    > {
+        #[cfg(test)]
+        // Check equivalence to result from primitives::sinsemilla::hash_to_point
+        {
+            use crate::sinsemilla::primitives::{K, S_PERSONALIZATION};
+
+            use group::{prime::PrimeCurveAffine, Curve};
+            use pasta_curves::arithmetic::CurveExt;
+
+            let field_elems: Value<Vec<_>> = message
+                .iter()
+                .map(|piece| piece.field_elem().map(|elem| (elem, piece.num_words())))
+                .collect();
+
+            let value_Q = match Q {
+                EccPointQ::PublicPoint(p) => Value::known(p),
+                EccPointQ::PrivatePoint(p) => p.point(),
+            };
+
+            field_elems
+                .zip(x_a.value().zip(y_a.value()))
+                .zip(value_Q)
+                .assert_if_known(|((field_elems, (x_a, y_a)), value_Q)| {
+                    // Get message as a bitstring.
+                    let bitstring: Vec<bool> = field_elems
+                        .iter()
+                        .flat_map(|(elem, num_words)| {
+                            elem.to_le_bits().into_iter().take(K * num_words)
+                        })
+                        .collect();
+
+                    let hasher_S = pallas::Point::hash_to_curve(S_PERSONALIZATION);
+                    let S = |chunk: &[bool]| hasher_S(&lebs2ip_k(chunk).to_le_bytes());
+
+                    // We can use complete addition here because it differs from
+                    // incomplete addition with negligible probability.
+                    let expected_point = bitstring
+                        .chunks(K)
+                        .fold(value_Q.to_curve(), |acc, chunk| (acc + S(chunk)) + acc);
+                    let actual_point =
+                        pallas::Affine::from_xy(x_a.evaluate(), y_a.evaluate()).unwrap();
+                    expected_point.to_affine() == actual_point
+                });
+        }
+
+        x_a.value()
+            .zip(y_a.value())
+            .error_if_known_and(|(x_a, y_a)| x_a.is_zero_vartime() || y_a.is_zero_vartime())?;
+        Ok((
+            NonIdentityEccPoint::from_coordinates_unchecked(x_a.0, y_a),
+            zs_sum,
+        ))
+    }
 }
 
 /// The x-coordinate of the accumulator in a Sinsemilla hash instance.
diff --git a/halo2_gadgets/src/sinsemilla/merkle.rs b/halo2_gadgets/src/sinsemilla/merkle.rs
index 02a3bdaf7c..b047a7e86d 100644
--- a/halo2_gadgets/src/sinsemilla/merkle.rs
+++ b/halo2_gadgets/src/sinsemilla/merkle.rs
@@ -184,7 +184,12 @@ pub mod tests {
             tests::{TestCommitDomain, TestHashDomain},
             HashDomains,
         },
-        utilities::{i2lebsp, lookup_range_check::LookupRangeCheckConfig, UtilitiesInstructions},
+        tests::test_utils::test_against_stored_circuit,
+        utilities::{
+            i2lebsp,
+            lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
+            UtilitiesInstructions,
+        },
     };
 
     use group::ff::{Field, PrimeField, PrimeFieldBits};
@@ -196,26 +201,44 @@ pub mod tests {
     };
 
     use rand::{rngs::OsRng, RngCore};
-    use std::{convert::TryInto, iter};
+    use std::{convert::TryInto, iter, marker::PhantomData};
 
     const MERKLE_DEPTH: usize = 32;
 
     #[derive(Default)]
-    struct MyCircuit {
+    struct MyCircuit<Lookup: PallasLookupRangeCheck> {
         leaf: Value<pallas::Base>,
         leaf_pos: Value<u32>,
         merkle_path: Value<[pallas::Base; MERKLE_DEPTH]>,
+        _lookup_marker: PhantomData<Lookup>,
+    }
+
+    impl<Lookup: PallasLookupRangeCheck> MyCircuit<Lookup> {
+        fn new(
+            leaf: Value<pallas::Base>,
+            leaf_pos: Value<u32>,
+            merkle_path: Value<[pallas::Base; MERKLE_DEPTH]>,
+        ) -> Self {
+            Self {
+                leaf,
+                leaf_pos,
+                merkle_path,
+                _lookup_marker: PhantomData,
+            }
+        }
     }
 
-    impl Circuit<pallas::Base> for MyCircuit {
-        type Config = (
-            MerkleConfig<TestHashDomain, TestCommitDomain, TestFixedBases>,
-            MerkleConfig<TestHashDomain, TestCommitDomain, TestFixedBases>,
-        );
+    type MyConfig<Lookup> = (
+        MerkleConfig<TestHashDomain, TestCommitDomain, TestFixedBases, Lookup>,
+        MerkleConfig<TestHashDomain, TestCommitDomain, TestFixedBases, Lookup>,
+    );
+
+    impl<Lookup: PallasLookupRangeCheck> Circuit<pallas::Base> for MyCircuit<Lookup> {
+        type Config = MyConfig<Lookup>;
         type FloorPlanner = SimpleFloorPlanner;
 
         fn without_witnesses(&self) -> Self {
-            Self::default()
+            MyCircuit::new(Value::default(), Value::default(), Value::default())
         }
 
         fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
@@ -248,7 +271,7 @@ pub mod tests {
                 meta.lookup_table_column(),
             );
 
-            let range_check = LookupRangeCheckConfig::configure(meta, advices[9], lookup.0);
+            let range_check = Lookup::configure(meta, advices[9], lookup.0);
 
             let sinsemilla_config_1 = SinsemillaChip::configure(
                 meta,
@@ -279,7 +302,7 @@ pub mod tests {
             mut layouter: impl Layouter<pallas::Base>,
         ) -> Result<(), Error> {
             // Load generator table (shared across both configs)
-            SinsemillaChip::<TestHashDomain, TestCommitDomain, TestFixedBases>::load(
+            SinsemillaChip::<TestHashDomain, TestCommitDomain, TestFixedBases, Lookup>::load(
                 config.0.sinsemilla_config.clone(),
                 &mut layouter,
             )?;
@@ -355,8 +378,7 @@ pub mod tests {
         }
     }
 
-    #[test]
-    fn merkle_chip() {
+    fn generate_circuit<Lookup: PallasLookupRangeCheck>() -> MyCircuit<Lookup> {
         let mut rng = OsRng;
 
         // Choose a random leaf and position
@@ -369,17 +391,27 @@ pub mod tests {
             .collect();
 
         // The root is provided as a public input in the Orchard circuit.
+        MyCircuit::new(
+            Value::known(leaf),
+            Value::known(pos),
+            Value::known(path.try_into().unwrap()),
+        )
+    }
 
-        let circuit = MyCircuit {
-            leaf: Value::known(leaf),
-            leaf_pos: Value::known(pos),
-            merkle_path: Value::known(path.try_into().unwrap()),
-        };
+    #[test]
+    fn merkle_chip() {
+        let circuit: MyCircuit<PallasLookupRangeCheckConfig> = generate_circuit();
 
         let prover = MockProver::run(11, &circuit, vec![]).unwrap();
         assert_eq!(prover.verify(), Ok(()))
     }
 
+    #[test]
+    fn test_merkle_chip_against_stored_circuit() {
+        let circuit: MyCircuit<PallasLookupRangeCheckConfig> = generate_circuit();
+        test_against_stored_circuit(circuit, "merkle_chip", 4160);
+    }
+
     #[cfg(feature = "test-dev-graph")]
     #[test]
     fn print_merkle_chip() {
@@ -389,7 +421,12 @@ pub mod tests {
         root.fill(&WHITE).unwrap();
         let root = root.titled("MerkleCRH Path", ("sans-serif", 60)).unwrap();
 
-        let circuit = MyCircuit::default();
+        let circuit: MyCircuit<PallasLookupRangeCheckConfig> = MyCircuit {
+            leaf: Value::default(),
+            leaf_pos: Value::default(),
+            merkle_path: Value::default(),
+            _lookup_marker: PhantomData,
+        };
         halo2_proofs::dev::CircuitLayout::default()
             .show_labels(false)
             .render(11, &circuit, &root)
diff --git a/halo2_gadgets/src/sinsemilla/merkle/chip.rs b/halo2_gadgets/src/sinsemilla/merkle/chip.rs
index 2c37fe924b..bc076f6c55 100644
--- a/halo2_gadgets/src/sinsemilla/merkle/chip.rs
+++ b/halo2_gadgets/src/sinsemilla/merkle/chip.rs
@@ -11,7 +11,10 @@ use super::MerkleInstructions;
 
 use crate::{
     sinsemilla::{primitives as sinsemilla, MessagePiece},
-    utilities::RangeConstrained,
+    utilities::{
+        lookup_range_check::{PallasLookupRangeCheck, PallasLookupRangeCheckConfig},
+        RangeConstrained,
+    },
     {
         ecc::FixedPoints,
         sinsemilla::{
@@ -28,16 +31,17 @@ use group::ff::PrimeField;
 
 /// Configuration for the `MerkleChip` implementation.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct MerkleConfig<Hash, Commit, Fixed>
+pub struct MerkleConfig<Hash, Commit, Fixed, Lookup = PallasLookupRangeCheckConfig>
 where
     Hash: HashDomains<pallas::Affine>,
     Fixed: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, Fixed, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
     advices: [Column<Advice>; 5],
     q_decompose: Selector,
     pub(super) cond_swap_config: CondSwapConfig,
-    pub(super) sinsemilla_config: SinsemillaConfig<Hash, Commit, Fixed>,
+    pub(super) sinsemilla_config: SinsemillaConfig<Hash, Commit, Fixed, Lookup>,
 }
 
 /// Chip implementing `MerkleInstructions`.
@@ -51,22 +55,24 @@ where
 /// This chip does **NOT** constrain `left⋆` and `right⋆` to be canonical encodings of
 /// `left` and `right`.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct MerkleChip<Hash, Commit, Fixed>
+pub struct MerkleChip<Hash, Commit, Fixed, Lookup = PallasLookupRangeCheckConfig>
 where
     Hash: HashDomains<pallas::Affine>,
     Fixed: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, Fixed, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
-    config: MerkleConfig<Hash, Commit, Fixed>,
+    config: MerkleConfig<Hash, Commit, Fixed, Lookup>,
 }
 
-impl<Hash, Commit, Fixed> Chip<pallas::Base> for MerkleChip<Hash, Commit, Fixed>
+impl<Hash, Commit, Fixed, Lookup> Chip<pallas::Base> for MerkleChip<Hash, Commit, Fixed, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     Fixed: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, Fixed, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
-    type Config = MerkleConfig<Hash, Commit, Fixed>;
+    type Config = MerkleConfig<Hash, Commit, Fixed, Lookup>;
     type Loaded = ();
 
     fn config(&self) -> &Self::Config {
@@ -78,17 +84,18 @@ where
     }
 }
 
-impl<Hash, Commit, F> MerkleChip<Hash, Commit, F>
+impl<Hash, Commit, F, Lookup> MerkleChip<Hash, Commit, F, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     F: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, F, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
     /// Configures the [`MerkleChip`].
     pub fn configure(
         meta: &mut ConstraintSystem<pallas::Base>,
-        sinsemilla_config: SinsemillaConfig<Hash, Commit, F>,
-    ) -> MerkleConfig<Hash, Commit, F> {
+        sinsemilla_config: SinsemillaConfig<Hash, Commit, F, Lookup>,
+    ) -> MerkleConfig<Hash, Commit, F, Lookup> {
         // All five advice columns are equality-enabled by SinsemillaConfig.
         let advices = sinsemilla_config.advices();
         let cond_swap_config = CondSwapChip::configure(meta, advices);
@@ -191,18 +198,19 @@ where
     }
 
     /// Constructs a [`MerkleChip`] given a [`MerkleConfig`].
-    pub fn construct(config: MerkleConfig<Hash, Commit, F>) -> Self {
+    pub fn construct(config: MerkleConfig<Hash, Commit, F, Lookup>) -> Self {
         MerkleChip { config }
     }
 }
 
-impl<Hash, Commit, F, const MERKLE_DEPTH: usize>
+impl<Hash, Commit, Fixed, Lookup, const MERKLE_DEPTH: usize>
     MerkleInstructions<pallas::Affine, MERKLE_DEPTH, { sinsemilla::K }, { sinsemilla::C }>
-    for MerkleChip<Hash, Commit, F>
+    for MerkleChip<Hash, Commit, Fixed, Lookup>
 where
     Hash: HashDomains<pallas::Affine> + Eq,
-    F: FixedPoints<pallas::Affine>,
-    Commit: CommitDomains<pallas::Affine, F, Hash> + Eq,
+    Fixed: FixedPoints<pallas::Affine>,
+    Commit: CommitDomains<pallas::Affine, Fixed, Hash> + Eq,
+    Lookup: PallasLookupRangeCheck,
 {
     #[allow(non_snake_case)]
     fn hash_layer(
@@ -415,20 +423,24 @@ where
     }
 }
 
-impl<Hash, Commit, F> UtilitiesInstructions<pallas::Base> for MerkleChip<Hash, Commit, F>
+impl<Hash, Commit, F, Lookup> UtilitiesInstructions<pallas::Base>
+    for MerkleChip<Hash, Commit, F, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     F: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, F, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
     type Var = AssignedCell<pallas::Base, pallas::Base>;
 }
 
-impl<Hash, Commit, F> CondSwapInstructions<pallas::Base> for MerkleChip<Hash, Commit, F>
+impl<Hash, Commit, F, Lookup> CondSwapInstructions<pallas::Base>
+    for MerkleChip<Hash, Commit, F, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     F: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, F, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
     #[allow(clippy::type_complexity)]
     fn swap(
@@ -443,57 +455,59 @@ where
     }
 }
 
-impl<Hash, Commit, F> SinsemillaInstructions<pallas::Affine, { sinsemilla::K }, { sinsemilla::C }>
-    for MerkleChip<Hash, Commit, F>
+impl<Hash, Commit, F, Lookup>
+    SinsemillaInstructions<pallas::Affine, { sinsemilla::K }, { sinsemilla::C }>
+    for MerkleChip<Hash, Commit, F, Lookup>
 where
     Hash: HashDomains<pallas::Affine>,
     F: FixedPoints<pallas::Affine>,
     Commit: CommitDomains<pallas::Affine, F, Hash>,
+    Lookup: PallasLookupRangeCheck,
 {
-    type CellValue = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<
+    type CellValue = <SinsemillaChip<Hash, Commit, F, Lookup> as SinsemillaInstructions<
         pallas::Affine,
         { sinsemilla::K },
         { sinsemilla::C },
     >>::CellValue;
 
-    type Message = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<
+    type Message = <SinsemillaChip<Hash, Commit, F, Lookup> as SinsemillaInstructions<
         pallas::Affine,
         { sinsemilla::K },
         { sinsemilla::C },
     >>::Message;
-    type MessagePiece = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<
+    type MessagePiece = <SinsemillaChip<Hash, Commit, F, Lookup> as SinsemillaInstructions<
         pallas::Affine,
         { sinsemilla::K },
         { sinsemilla::C },
     >>::MessagePiece;
-    type RunningSum = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<
+    type RunningSum = <SinsemillaChip<Hash, Commit, F, Lookup> as SinsemillaInstructions<
         pallas::Affine,
         { sinsemilla::K },
         { sinsemilla::C },
     >>::RunningSum;
 
-    type X = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<
+    type X = <SinsemillaChip<Hash, Commit, F, Lookup> as SinsemillaInstructions<
         pallas::Affine,
         { sinsemilla::K },
         { sinsemilla::C },
     >>::X;
-    type NonIdentityPoint = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<
+    type NonIdentityPoint = <SinsemillaChip<Hash, Commit, F, Lookup> as SinsemillaInstructions<
         pallas::Affine,
         { sinsemilla::K },
         { sinsemilla::C },
     >>::NonIdentityPoint;
-    type FixedPoints = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<
+    type FixedPoints = <SinsemillaChip<Hash, Commit, F, Lookup> as SinsemillaInstructions<
         pallas::Affine,
         { sinsemilla::K },
         { sinsemilla::C },
     >>::FixedPoints;
 
-    type HashDomains = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<
+    type HashDomains = <SinsemillaChip<Hash, Commit, F, Lookup> as SinsemillaInstructions<
         pallas::Affine,
         { sinsemilla::K },
         { sinsemilla::C },
     >>::HashDomains;
-    type CommitDomains = <SinsemillaChip<Hash, Commit, F> as SinsemillaInstructions<
+    type CommitDomains = <SinsemillaChip<Hash, Commit, F, Lookup> as SinsemillaInstructions<
         pallas::Affine,
         { sinsemilla::K },
         { sinsemilla::C },
@@ -506,7 +520,7 @@ where
         num_words: usize,
     ) -> Result<Self::MessagePiece, Error> {
         let config = self.config().sinsemilla_config.clone();
-        let chip = SinsemillaChip::<Hash, Commit, F>::construct(config);
+        let chip = SinsemillaChip::<Hash, Commit, F, Lookup>::construct(config);
         chip.witness_message_piece(layouter, value, num_words)
     }
 
@@ -519,11 +533,11 @@ where
         message: Self::Message,
     ) -> Result<(Self::NonIdentityPoint, Vec<Vec<Self::CellValue>>), Error> {
         let config = self.config().sinsemilla_config.clone();
-        let chip = SinsemillaChip::<Hash, Commit, F>::construct(config);
+        let chip = SinsemillaChip::<Hash, Commit, F, Lookup>::construct(config);
         chip.hash_to_point(layouter, Q, message)
     }
 
     fn extract(point: &Self::NonIdentityPoint) -> Self::X {
-        SinsemillaChip::<Hash, Commit, F>::extract(point)
+        SinsemillaChip::<Hash, Commit, F, Lookup>::extract(point)
     }
 }
diff --git a/halo2_gadgets/src/tests.rs b/halo2_gadgets/src/tests.rs
new file mode 100644
index 0000000000..1d00cc79b7
--- /dev/null
+++ b/halo2_gadgets/src/tests.rs
@@ -0,0 +1 @@
+pub(crate) mod test_utils;
diff --git a/halo2_gadgets/src/tests/circuit_data/proof_ecc_chip.bin b/halo2_gadgets/src/tests/circuit_data/proof_ecc_chip.bin
new file mode 100644
index 0000000000..49272038e5
Binary files /dev/null and b/halo2_gadgets/src/tests/circuit_data/proof_ecc_chip.bin differ
diff --git a/halo2_gadgets/src/tests/circuit_data/proof_lookup_range_check.bin b/halo2_gadgets/src/tests/circuit_data/proof_lookup_range_check.bin
new file mode 100644
index 0000000000..387b82bba4
Binary files /dev/null and b/halo2_gadgets/src/tests/circuit_data/proof_lookup_range_check.bin differ
diff --git a/halo2_gadgets/src/tests/circuit_data/proof_merkle_chip.bin b/halo2_gadgets/src/tests/circuit_data/proof_merkle_chip.bin
new file mode 100644
index 0000000000..abce3ef943
Binary files /dev/null and b/halo2_gadgets/src/tests/circuit_data/proof_merkle_chip.bin differ
diff --git a/halo2_gadgets/src/tests/circuit_data/proof_short_range_check_case0.bin b/halo2_gadgets/src/tests/circuit_data/proof_short_range_check_case0.bin
new file mode 100644
index 0000000000..4505de5607
Binary files /dev/null and b/halo2_gadgets/src/tests/circuit_data/proof_short_range_check_case0.bin differ
diff --git a/halo2_gadgets/src/tests/circuit_data/proof_short_range_check_case1.bin b/halo2_gadgets/src/tests/circuit_data/proof_short_range_check_case1.bin
new file mode 100644
index 0000000000..59ca18d63f
Binary files /dev/null and b/halo2_gadgets/src/tests/circuit_data/proof_short_range_check_case1.bin differ
diff --git a/halo2_gadgets/src/tests/circuit_data/proof_short_range_check_case2.bin b/halo2_gadgets/src/tests/circuit_data/proof_short_range_check_case2.bin
new file mode 100644
index 0000000000..f3fecdd64d
Binary files /dev/null and b/halo2_gadgets/src/tests/circuit_data/proof_short_range_check_case2.bin differ
diff --git a/halo2_gadgets/src/tests/circuit_data/proof_sinsemilla_chip.bin b/halo2_gadgets/src/tests/circuit_data/proof_sinsemilla_chip.bin
new file mode 100644
index 0000000000..7c0faeff43
Binary files /dev/null and b/halo2_gadgets/src/tests/circuit_data/proof_sinsemilla_chip.bin differ
diff --git a/halo2_gadgets/src/tests/circuit_data/vk_ecc_chip.rdata b/halo2_gadgets/src/tests/circuit_data/vk_ecc_chip.rdata
new file mode 100644
index 0000000000..5eb13f31e1
--- /dev/null
+++ b/halo2_gadgets/src/tests/circuit_data/vk_ecc_chip.rdata
@@ -0,0 +1,9915 @@
+PinnedVerificationKey {
+    base_modulus: "0x40000000000000000000000000000000224698fc0994a8dd8c46eb2100000001",
+    scalar_modulus: "0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001",
+    domain: PinnedEvaluationDomain {
+        k: 11,
+        extended_k: 14,
+        omega: 0x181b50ad5f32119e31cbd395426d600b7a9b88bcaaa1c24eef28545aada17813,
+    },
+    cs: PinnedConstraintSystem {
+        num_fixed_columns: 19,
+        num_advice_columns: 10,
+        num_instance_columns: 0,
+        num_selectors: 20,
+        gates: [
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 13,
+                                            column_index: 13,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 13,
+                                        column_index: 13,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 2,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    -1,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                        ),
+                        Advice {
+                            query_index: 1,
+                            column_index: 9,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Product(
+                                    Fixed {
+                                        query_index: 13,
+                                        column_index: 13,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                        ),
+                                        Negated(
+                                            Fixed {
+                                                query_index: 13,
+                                                column_index: 13,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000003,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 13,
+                                            column_index: 13,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000004,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 13,
+                                        column_index: 13,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000005,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 3,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Product(
+                                    Fixed {
+                                        query_index: 13,
+                                        column_index: 13,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                        ),
+                                        Negated(
+                                            Fixed {
+                                                query_index: 13,
+                                                column_index: 13,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000003,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 13,
+                                            column_index: 13,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000004,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 13,
+                                        column_index: 13,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000005,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 4,
+                        column_index: 1,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 13,
+                                            column_index: 13,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 13,
+                                        column_index: 13,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 13,
+                                            column_index: 13,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 13,
+                                        column_index: 13,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Product(
+                            Sum(
+                                Sum(
+                                    Advice {
+                                        query_index: 7,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 5,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 5,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 13,
+                                            column_index: 13,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 13,
+                                        column_index: 13,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 8,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 7,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 5,
+                            column_index: 2,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 4,
+                                        column_index: 1,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 5,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Advice {
+                                            query_index: 3,
+                                            column_index: 0,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Product(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Sum(
+                            Sum(
+                                Product(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 7,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Advice {
+                                            query_index: 7,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 8,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Sum(
+                        Sum(
+                            Sum(
+                                Product(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 7,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Advice {
+                                            query_index: 7,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 8,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 7,
+                            column_index: 2,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 8,
+                            column_index: 3,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 7,
+                            column_index: 2,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 8,
+                            column_index: 3,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Advice {
+                                        query_index: 10,
+                                        column_index: 5,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 4,
+                                        column_index: 1,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 13,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 7,
+                        column_index: 2,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Advice {
+                                        query_index: 10,
+                                        column_index: 5,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 4,
+                                        column_index: 1,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 13,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 8,
+                        column_index: 3,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 13,
+                                            column_index: 13,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 13,
+                                        column_index: 13,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 9,
+                        column_index: 4,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Scaled(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 14,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 15,
+                                        column_index: 5,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 8,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Sum(
+                                            Sum(
+                                                Product(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 8,
+                                                        column_index: 3,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 16,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 3,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Advice {
+                            query_index: 16,
+                            column_index: 0,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 4,
+                        column_index: 1,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Advice {
+                            query_index: 17,
+                            column_index: 1,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 2,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 2,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 10,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 6,
+                                                            column_index: 3,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Scaled(
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 2,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 8,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Sum(
+                                Sum(
+                                    Product(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 6,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 8,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 10,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 6,
+                                                            column_index: 3,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Scaled(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 14,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 15,
+                                        column_index: 5,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 8,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Sum(
+                                            Sum(
+                                                Product(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 8,
+                                                        column_index: 3,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 16,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 2,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 2,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 10,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 6,
+                                                            column_index: 3,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Scaled(
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 2,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 8,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Sum(
+                                Sum(
+                                    Product(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 6,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 8,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 10,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 6,
+                                                            column_index: 3,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 14,
+                            column_index: 4,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 14,
+                                        column_index: 14,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 14,
+                                    column_index: 14,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 14,
+                                column_index: 14,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Scaled(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 19,
+                                        column_index: 8,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 7,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Sum(
+                                            Sum(
+                                                Product(
+                                                    Advice {
+                                                        query_index: 19,
+                                                        column_index: 8,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    Advice {
+                                                        query_index: 19,
+                                                        column_index: 8,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 18,
+                                                        column_index: 7,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 16,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 3,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Advice {
+                            query_index: 16,
+                            column_index: 0,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 4,
+                        column_index: 1,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Advice {
+                            query_index: 17,
+                            column_index: 1,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 11,
+                            column_index: 6,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 20,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 20,
+                                            column_index: 6,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 13,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 7,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Scaled(
+                                Sum(
+                                    Advice {
+                                        query_index: 11,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 20,
+                                                column_index: 6,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 18,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Sum(
+                                Sum(
+                                    Product(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 12,
+                            column_index: 7,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 7,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Scaled(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 19,
+                                        column_index: 8,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 7,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Sum(
+                                            Sum(
+                                                Product(
+                                                    Advice {
+                                                        query_index: 19,
+                                                        column_index: 8,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    Advice {
+                                                        query_index: 19,
+                                                        column_index: 8,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 18,
+                                                        column_index: 7,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 16,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 11,
+                            column_index: 6,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 20,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 20,
+                                            column_index: 6,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 13,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 7,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Scaled(
+                                Sum(
+                                    Advice {
+                                        query_index: 11,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 20,
+                                                column_index: 6,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 18,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Sum(
+                                Sum(
+                                    Product(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 12,
+                            column_index: 7,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 7,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 19,
+                            column_index: 8,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 1,
+                            column_index: 9,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Product(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Advice {
+                                    query_index: 2,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 1,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                Negated(
+                                    Product(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                        Advice {
+                                            query_index: 2,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 1,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Negated(
+                                Product(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Advice {
+                                        query_index: 2,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            -1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 0,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 21,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 1,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Product(
+                                            Constant(
+                                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                                            ),
+                                            Advice {
+                                                query_index: 2,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 0,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 21,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    -1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Product(
+                                Advice {
+                                    query_index: 23,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                Product(
+                                    Constant(
+                                        0x0000000000000000000000000000000010000000000000000000000000000000,
+                                    ),
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000040,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Advice {
+                            query_index: 20,
+                            column_index: 6,
+                            rotation: Rotation(
+                                -1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x00000000000000000000000000000000224698fc0994a8dd8c46eb2100000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 23,
+                        column_index: 7,
+                        rotation: Rotation(
+                            -1,
+                        ),
+                    },
+                    Sum(
+                        Advice {
+                            query_index: 11,
+                            column_index: 6,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Constant(
+                                0x0000000000000000000000000000000010000000000000000000000000000000,
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 23,
+                        column_index: 7,
+                        rotation: Rotation(
+                            -1,
+                        ),
+                    },
+                    Advice {
+                        query_index: 18,
+                        column_index: 7,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 23,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Product(
+                                    Advice {
+                                        query_index: 11,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 22,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 18,
+                        column_index: 7,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 1,
+                            column_index: 9,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 1,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 0,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 1,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 3,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Product(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 1,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 0,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 16,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 15,
+                                            column_index: 15,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 15,
+                                        column_index: 15,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 15,
+                                    column_index: 15,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 15,
+                                column_index: 15,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 1,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Product(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 1,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 0,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 17,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 16,
+                    column_index: 16,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Constant(
+                                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                ),
+                                                Negated(
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Constant(
+                                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                                            ),
+                                            Negated(
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                                        ),
+                                        Negated(
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000004,
+                                    ),
+                                    Negated(
+                                        Sum(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Scaled(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000005,
+                                ),
+                                Negated(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Scaled(
+                                                Advice {
+                                                    query_index: 14,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000006,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 14,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000007,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 14,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 16,
+                    column_index: 16,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Sum(
+                            Sum(
+                                Sum(
+                                    Sum(
+                                        Sum(
+                                            Sum(
+                                                Sum(
+                                                    Constant(
+                                                        0x0000000000000000000000000000000000000000000000000000000000000000,
+                                                    ),
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Fixed {
+                                                            query_index: 3,
+                                                            column_index: 1,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Fixed {
+                                                        query_index: 4,
+                                                        column_index: 2,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Fixed {
+                                                    query_index: 5,
+                                                    column_index: 3,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Fixed {
+                                                query_index: 6,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Fixed {
+                                            query_index: 7,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Scaled(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Fixed {
+                                        query_index: 8,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Scaled(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Scaled(
+                                                Advice {
+                                                    query_index: 14,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                Fixed {
+                                    query_index: 9,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Product(
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Scaled(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Scaled(
+                                                Advice {
+                                                    query_index: 14,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 14,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Fixed {
+                                query_index: 10,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 3,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 16,
+                    column_index: 16,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Fixed {
+                            query_index: 2,
+                            column_index: 10,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 16,
+                    column_index: 16,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 17,
+                    column_index: 17,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Sum(
+                            Sum(
+                                Sum(
+                                    Sum(
+                                        Sum(
+                                            Sum(
+                                                Sum(
+                                                    Constant(
+                                                        0x0000000000000000000000000000000000000000000000000000000000000000,
+                                                    ),
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Fixed {
+                                                            query_index: 3,
+                                                            column_index: 1,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Fixed {
+                                                        query_index: 4,
+                                                        column_index: 2,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Fixed {
+                                                    query_index: 5,
+                                                    column_index: 3,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Fixed {
+                                                query_index: 6,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Fixed {
+                                            query_index: 7,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Fixed {
+                                        query_index: 8,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Fixed {
+                                    query_index: 9,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Product(
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Fixed {
+                                query_index: 10,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 3,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 17,
+                    column_index: 17,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Fixed {
+                            query_index: 2,
+                            column_index: 10,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 17,
+                    column_index: 17,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 17,
+                    column_index: 17,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Sum(
+                                                Constant(
+                                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Constant(
+                                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000004,
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000005,
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000006,
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000007,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 10,
+                        column_index: 5,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Advice {
+                            query_index: 9,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 9,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 6,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Advice {
+                            query_index: 9,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 6,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Advice {
+                        query_index: 12,
+                        column_index: 7,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Advice {
+                            query_index: 18,
+                            column_index: 7,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 24,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                Constant(
+                                    0x0000000000000000000000000000000001000000000000000000000000000000,
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 19,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 19,
+                                        column_index: 8,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 18,
+                                                column_index: 7,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Advice {
+                        query_index: 22,
+                        column_index: 6,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 12,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 13,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 24,
+                        column_index: 8,
+                        rotation: Rotation(
+                            -1,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Scaled(
+                                Advice {
+                                    query_index: 13,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Fixed {
+                        query_index: 18,
+                        column_index: 18,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 11,
+                        column_index: 6,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Sum(
+                                Sum(
+                                    Advice {
+                                        query_index: 20,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            -1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 24,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x1000000000000000000000000000000000000000000000000000000000000000,
+                                        ),
+                                    ),
+                                ),
+                                Constant(
+                                    0x0000000000000000000000000000000400000000000000000000000000000000,
+                                ),
+                            ),
+                            Negated(
+                                Constant(
+                                    0x00000000000000000000000000000000224698fc094cf91b992d30ed00000001,
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ],
+        advice_queries: [
+            (
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 5,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 5,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+        ],
+        instance_queries: [],
+        fixed_queries: [
+            (
+                Column {
+                    index: 9,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 10,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 5,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 11,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 12,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 13,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 14,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 15,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 16,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 17,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 18,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+        ],
+        permutation: Argument {
+            columns: [
+                Column {
+                    index: 9,
+                    column_type: Fixed,
+                },
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 2,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 3,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 4,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 5,
+                    column_type: Advice,
+                },
+            ],
+        },
+        lookups: [
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 11,
+                            column_index: 11,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Product(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 1,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 12,
+                                            column_index: 12,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+        ],
+        constants: [
+            Column {
+                index: 9,
+                column_type: Fixed,
+            },
+        ],
+        minimum_degree: None,
+    },
+    fixed_commitments: [
+        (0x05f5862cad2888855bc3c1843a9eff57b11b592d9eb0e13354256661387f5231, 0x32236b14df85bf5f532a930232cb23a5c56ef7d67aaeed8bcb8fc10ea132cbd6),
+        (0x15e9797cbf96b3ab5f2a21595a5ede5becc665dbf113ae1bd93c5fdd577b3fdd, 0x2276c102a90057ccaac390724cd3e8032eaa0d5c7630b979e2f86354d46044fe),
+        (0x0a3757ecd8df677c56dd731a5988940130dc69375d09185120348b4c24f23f9a, 0x209e7e273d9d9254893a220d7329114fa83eda5d483437612cf638275b4d97f2),
+        (0x337f1898449ead1933c764ae23b48d20f646e528b079ac5cd0743d9ac8e8f063, 0x144e28d47be3a5d90eab8ec65a10b965fd83c7b34f8e4b387154f126efbbf7a7),
+        (0x1ba31dfd22b785ba6080c0a1378f14d104f571d6ab2ac6e650865b27296773db, 0x3c49108055aa494775123cb379dbee7ae628e193cba15827df962722a9a47367),
+        (0x0fdf7430975fbf9361ee6a0eef8e811b838cf64cb042d5988c669010329a8e8c, 0x1292f817500e4ef166ccf48483d061b41372ac7e44ed52b04fbf03da5b04fc79),
+        (0x145d45d803dfd99569e689c02583b2a63f004e25ba23bf9acc17148b42267480, 0x230efff0cad7a66c33eb7462b4b60237619e1287a6c23a122057ef0359d324a6),
+        (0x0ce14fcd6eef4247d75df3d38a918bd8d8c66362629ca8ca697254bf703f1dc9, 0x3cc92942c824cad0a3f16828a29dd42785485b878e459a289db7c377973f2aee),
+        (0x0bd58593a2e2657cd0a228b678a4a7ec04492e20768108383cfdae26613da0b9, 0x090c75a86508be75f6f57e33946c5f9170f40d08e058eb33c8370311fed2868c),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x1676bb18498c153055ba927b909ef96c5edf8108be253d7a86663f57cd815cd1, 0x0ca79754ab892586fe9df1ae7a23e527bbae042eb89e96747f3befe88c493446),
+        (0x2e0cad5df5c23f42086784fd79c09b1dff1718dd1700e5157a1592dec21306a8, 0x01cd2a585d4dacd1c4ebb7eccc804a7284792641900d383e9f6f496482c01144),
+        (0x2e0cad5df5c23f42086784fd79c09b1dff1718dd1700e5157a1592dec21306a8, 0x01cd2a585d4dacd1c4ebb7eccc804a7284792641900d383e9f6f496482c01144),
+        (0x11ee40a7ae1d9b3bc41a88dd50a69661de280c85222c5567ea3fc06c606558a5, 0x0c6ad5f6fb00347486477aededc92f686f6d079737fd2ca147b7db5ea7381061),
+        (0x33be67428155b1361122a6eddf7e24a7cbeddcce8166dead5d9d5ec6714b25f2, 0x3ec742ac0f64c3ffc4d47bbdeaba0603c55ef74d40065b84b7d738c95f473c79),
+        (0x11c136f6ea303c5630240788e7a4db6c3aa321aaeaebecbd473af5ace4d05248, 0x0afe33d04a38bae95c2ec4c4372b2d766369c4c5b10f82dcbd4375a41f838d79),
+        (0x320eb135936ed226a108ccc06bea1ce3ea57dfc2d708fc2ea868ee90330fe22b, 0x15f1174d43608cb597ad1708d2c15e6fcb399219662c75a476b34d51d7ef8f09),
+        (0x2157882bf836df0d37c2fe7b4c03c099712bf0f1f70475cf79a47a269cd05d6e, 0x2b21b30255ccaa0152b483916b033c38c54edaf1ae8987df41d4812affd004fa),
+        (0x0bb1ce75e6be204e3d006a0dd70adbc82e9babae94be0a0fcd0eba958bf78d95, 0x25af91a42e58455509f322ab700f45210e369a79cfc3635db30fa5298d46475b),
+    ],
+    permutation: VerifyingKey {
+        commitments: [
+            (0x2dfdfeda0fc01492b0884d17870ef7c30a6a59502ead966bb6c072b216ef7b33, 0x206d9ce95f9c1bfb675cd14130a877aa70650b7d1bb5cbf82f3fbfa517c2a19a),
+            (0x001deacc3520d2f07b82695befedaee3c62c595d80d0f406f473ab3e8c362213, 0x316bcc3ef777e42b96c36bbb95b41654dc91b4fbf264e3796267716917e0b63f),
+            (0x142095bd2f3ceed4e0ee7eaae4952488aa314d89f4755b81bc4f4df5e849947a, 0x0e6b8ab5b49069d21ea86f1d320c2959f144a3b1f284231312ea776f337b00b6),
+            (0x20bdfa7afff8a496620db915f9323e348b0ea52ccb0e5ef2a26cc5edfb4a3490, 0x033516b53f25239682efb9f0b6865a1841a2f80e88c08c9431f08906bf2ece95),
+            (0x3b3d22054a70b22ab2f4daabb0671df492f8ae365372d34f9ed9cbf053f77560, 0x386d905cc46f526544a620c7251d661cf09ec673efafce3bd36f59295e8c8e10),
+            (0x23bdd78c87775077ce68d63f15349c6851d18cef963e714fad7c182172539964, 0x36df72f765faa06fdc6e79e9b71557043f1b3c32677cbe852bfb89b9ff2adf73),
+            (0x1f058e8d0ce9494143e267f9190d4a8a0f4fc18cee14b9cbb00fd4324d028d2f, 0x053c9574cfa8f32a4795152eb742f40752011ad9704a6b7a05fdf2d660948eca),
+            (0x0c116eea00a8888c4a5917f514f323b993c732ad08d9655cbcfb3ea57645c1d3, 0x1811bf498434bba922e2eb1b1dfc3025bedd7fe7aecb3837a561c1e78ee56b05),
+            (0x1317f5890e3c536bc205f7ecc9e286414f7abcd160903ba663f33cd37821a1ac, 0x39d386ba96759c162f980de92743c908b4808e252d04309fc5c10fb48c8f5f17),
+            (0x05aa4e237c2775c8105b736664b7b873a3a0a35cda546e29439fdcd87c844afc, 0x36129c33ee883439d98e23d4fb625a22df4b8b62d41702d82b59eb264c649832),
+            (0x2e48423c28c290a75feb9d431f59ec36e48d9e88c3ff46a9e1dfb04ed894d88d, 0x00d3bb38bca1ec15ac2e79c8e9c093fb496cca52c58f2947b51537ce718d9060),
+        ],
+    },
+}
diff --git a/halo2_gadgets/src/tests/circuit_data/vk_lookup_range_check.rdata b/halo2_gadgets/src/tests/circuit_data/vk_lookup_range_check.rdata
new file mode 100644
index 0000000000..48948bcbc7
--- /dev/null
+++ b/halo2_gadgets/src/tests/circuit_data/vk_lookup_range_check.rdata
@@ -0,0 +1,244 @@
+PinnedVerificationKey {
+    base_modulus: "0x40000000000000000000000000000000224698fc0994a8dd8c46eb2100000001",
+    scalar_modulus: "0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001",
+    domain: PinnedEvaluationDomain {
+        k: 11,
+        extended_k: 14,
+        omega: 0x181b50ad5f32119e31cbd395426d600b7a9b88bcaaa1c24eef28545aada17813,
+    },
+    cs: PinnedConstraintSystem {
+        num_fixed_columns: 5,
+        num_advice_columns: 1,
+        num_instance_columns: 0,
+        num_selectors: 3,
+        gates: [
+            Product(
+                Fixed {
+                    query_index: 4,
+                    column_index: 4,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 2,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    -1,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                        ),
+                        Advice {
+                            query_index: 1,
+                            column_index: 0,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 0,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+        ],
+        advice_queries: [
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+        ],
+        instance_queries: [],
+        fixed_queries: [
+            (
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+        ],
+        permutation: Argument {
+            columns: [
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+            ],
+        },
+        lookups: [
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 2,
+                            column_index: 2,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Product(
+                                Fixed {
+                                    query_index: 3,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 1,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 3,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+        ],
+        constants: [
+            Column {
+                index: 1,
+                column_type: Fixed,
+            },
+        ],
+        minimum_degree: None,
+    },
+    fixed_commitments: [
+        (0x05f5862cad2888855bc3c1843a9eff57b11b592d9eb0e13354256661387f5231, 0x32236b14df85bf5f532a930232cb23a5c56ef7d67aaeed8bcb8fc10ea132cbd6),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x1e8ad0c6992851e2d92d368088d79e3326cd63e2a12bb086407dc3dbe0691fb0, 0x0895d1133a5889cf2a52bf5a7ac48502ac399a0088625be4db7aaec534ee8576),
+        (0x1e8ad0c6992851e2d92d368088d79e3326cd63e2a12bb086407dc3dbe0691fb0, 0x0895d1133a5889cf2a52bf5a7ac48502ac399a0088625be4db7aaec534ee8576),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+    ],
+    permutation: VerifyingKey {
+        commitments: [
+            (0x2477ff33a8671d640d752567c99805c0dda68328ddfff306b085f13be1fd9079, 0x3f7c0fa2ae0b1b7683c39103509711d525eb2dfb73ed21458b77b9d0de222923),
+            (0x1c85783d2128c72103589576bf9d4ed2a509202944a52b48db13848f9431439f, 0x0c363acac4903e6907846abb10920dcf7a2b8c7462ac37f64d0da5cf7f9a643e),
+        ],
+    },
+}
diff --git a/halo2_gadgets/src/tests/circuit_data/vk_merkle_chip.rdata b/halo2_gadgets/src/tests/circuit_data/vk_merkle_chip.rdata
new file mode 100644
index 0000000000..229243b02c
--- /dev/null
+++ b/halo2_gadgets/src/tests/circuit_data/vk_merkle_chip.rdata
@@ -0,0 +1,3271 @@
+PinnedVerificationKey {
+    base_modulus: "0x40000000000000000000000000000000224698fc0994a8dd8c46eb2100000001",
+    scalar_modulus: "0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001",
+    domain: PinnedEvaluationDomain {
+        k: 11,
+        extended_k: 14,
+        omega: 0x181b50ad5f32119e31cbd395426d600b7a9b88bcaaa1c24eef28545aada17813,
+    },
+    cs: PinnedConstraintSystem {
+        num_fixed_columns: 14,
+        num_advice_columns: 10,
+        num_instance_columns: 0,
+        num_selectors: 11,
+        gates: [
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 12,
+                                        column_index: 12,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 2,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    -1,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                        ),
+                        Advice {
+                            query_index: 1,
+                            column_index: 9,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 12,
+                                        column_index: 12,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Scaled(
+                        Fixed {
+                            query_index: 5,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                    ),
+                    Negated(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Sum(
+                                        Sum(
+                                            Product(
+                                                Advice {
+                                                    query_index: 6,
+                                                    column_index: 8,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Advice {
+                                                    query_index: 6,
+                                                    column_index: 8,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 3,
+                                                    column_index: 5,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 4,
+                                                column_index: 6,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 10,
+                    column_index: 10,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Sum(
+                            Sum(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                Sum(
+                                    Sum(
+                                        Product(
+                                            Advice {
+                                                query_index: 6,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 6,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 4,
+                                            column_index: 6,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Advice {
+                                query_index: 3,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 10,
+                    column_index: 10,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 0,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 3,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Sum(
+                            Sum(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 6,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 0,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 6,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 6,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 3,
+                                                                column_index: 5,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 4,
+                                                            column_index: 6,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Product(
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                        Negated(
+                                            Product(
+                                                Fixed {
+                                                    query_index: 2,
+                                                    column_index: 6,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Sum(
+                                                    Fixed {
+                                                        query_index: 2,
+                                                        column_index: 6,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 8,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 1,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 8,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 8,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 5,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 10,
+                                                            column_index: 6,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Scaled(
+                                    Product(
+                                        Fixed {
+                                            query_index: 2,
+                                            column_index: 6,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Sum(
+                                            Fixed {
+                                                query_index: 2,
+                                                column_index: 6,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Constant(
+                                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Advice {
+                                    query_index: 8,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 12,
+                                        column_index: 12,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 5,
+                        column_index: 7,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 0,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 12,
+                                        column_index: 12,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 6,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 0,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 12,
+                                        column_index: 12,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 0,
+                        column_index: 9,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 0,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 12,
+                                        column_index: 12,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Advice {
+                            query_index: 3,
+                            column_index: 5,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000400,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 1,
+                            column_index: 9,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 12,
+                                        column_index: 12,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Advice {
+                            query_index: 9,
+                            column_index: 5,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Scaled(
+                            Sum(
+                                Sum(
+                                    Advice {
+                                        query_index: 4,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 10,
+                                                column_index: 6,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                                        ),
+                                    ),
+                                ),
+                                Scaled(
+                                    Advice {
+                                        query_index: 7,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    0x0000000000000000000000000000000000000000000000000000000000000400,
+                                ),
+                            ),
+                            0x0001000000000000000000000000000000000000000000000000000000000000,
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 6,
+                            column_index: 8,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 12,
+                                        column_index: 12,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Advice {
+                            query_index: 8,
+                            column_index: 8,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Scaled(
+                            Advice {
+                                query_index: 5,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000020,
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 12,
+                                        column_index: 12,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 12,
+                                    column_index: 12,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 12,
+                                column_index: 12,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 10,
+                        column_index: 6,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Advice {
+                                query_index: 7,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Scaled(
+                                Advice {
+                                    query_index: 8,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000020,
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Fixed {
+                            query_index: 13,
+                            column_index: 13,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Scaled(
+                        Fixed {
+                            query_index: 7,
+                            column_index: 2,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                    ),
+                    Negated(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 14,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 15,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Sum(
+                                        Sum(
+                                            Product(
+                                                Advice {
+                                                    query_index: 14,
+                                                    column_index: 3,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Advice {
+                                                    query_index: 14,
+                                                    column_index: 3,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 11,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 12,
+                                                column_index: 1,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 11,
+                    column_index: 11,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Advice {
+                            query_index: 15,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 15,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Sum(
+                            Sum(
+                                Advice {
+                                    query_index: 18,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                Sum(
+                                    Sum(
+                                        Product(
+                                            Advice {
+                                                query_index: 14,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 14,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 11,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 1,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Advice {
+                                query_index: 11,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 11,
+                    column_index: 11,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 15,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 11,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 18,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Sum(
+                            Sum(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 14,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 15,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 11,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 11,
+                                                                column_index: 0,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 1,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Product(
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                        Negated(
+                                            Product(
+                                                Fixed {
+                                                    query_index: 6,
+                                                    column_index: 7,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Sum(
+                                                    Fixed {
+                                                        query_index: 6,
+                                                        column_index: 7,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 17,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 19,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 18,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 17,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 17,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 18,
+                                                                column_index: 0,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 20,
+                                                            column_index: 1,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Scaled(
+                                    Product(
+                                        Fixed {
+                                            query_index: 6,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Sum(
+                                            Fixed {
+                                                query_index: 6,
+                                                column_index: 7,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Constant(
+                                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Advice {
+                                    query_index: 17,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Fixed {
+                            query_index: 13,
+                            column_index: 13,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 13,
+                        column_index: 2,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 15,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 15,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Fixed {
+                            query_index: 13,
+                            column_index: 13,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 14,
+                        column_index: 3,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 15,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 15,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Fixed {
+                            query_index: 13,
+                            column_index: 13,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 15,
+                        column_index: 4,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 15,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Fixed {
+                            query_index: 13,
+                            column_index: 13,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Advice {
+                            query_index: 11,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 18,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000400,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 19,
+                            column_index: 4,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Fixed {
+                            query_index: 13,
+                            column_index: 13,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Advice {
+                            query_index: 18,
+                            column_index: 0,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Scaled(
+                            Sum(
+                                Sum(
+                                    Advice {
+                                        query_index: 12,
+                                        column_index: 1,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 20,
+                                                column_index: 1,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                                        ),
+                                    ),
+                                ),
+                                Scaled(
+                                    Advice {
+                                        query_index: 16,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    0x0000000000000000000000000000000000000000000000000000000000000400,
+                                ),
+                            ),
+                            0x0001000000000000000000000000000000000000000000000000000000000000,
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 14,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Fixed {
+                            query_index: 13,
+                            column_index: 13,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Advice {
+                            query_index: 17,
+                            column_index: 3,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Scaled(
+                            Advice {
+                                query_index: 13,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000020,
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 15,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Fixed {
+                            query_index: 13,
+                            column_index: 13,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 13,
+                                    column_index: 13,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 13,
+                                column_index: 13,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 20,
+                        column_index: 1,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Advice {
+                                query_index: 16,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Scaled(
+                                Advice {
+                                    query_index: 17,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000020,
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ],
+        advice_queries: [
+            (
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+            (
+                Column {
+                    index: 5,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 5,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+        ],
+        instance_queries: [],
+        fixed_queries: [
+            (
+                Column {
+                    index: 0,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 5,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 9,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 10,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 11,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 12,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 13,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+        ],
+        permutation: Argument {
+            columns: [
+                Column {
+                    index: 0,
+                    column_type: Fixed,
+                },
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 5,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 2,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 3,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 4,
+                    column_type: Advice,
+                },
+            ],
+        },
+        lookups: [
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 8,
+                            column_index: 8,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Product(
+                                Fixed {
+                                    query_index: 9,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 1,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 9,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 3,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 10,
+                            column_index: 10,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Advice {
+                                query_index: 5,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Fixed {
+                                                query_index: 2,
+                                                column_index: 6,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Product(
+                                                    Fixed {
+                                                        query_index: 2,
+                                                        column_index: 6,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Sum(
+                                                        Fixed {
+                                                            query_index: 2,
+                                                            column_index: 6,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Constant(
+                                                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Advice {
+                                            query_index: 7,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000400,
+                                ),
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Fixed {
+                                query_index: 10,
+                                column_index: 10,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 6,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Scaled(
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 10,
+                                        column_index: 10,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            0x0db5218be6881f0f1431d4ea7d4afc7b29a05bafbede62b55a91eb912044ea5f,
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Fixed {
+                                query_index: 10,
+                                column_index: 10,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 6,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 0,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 6,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 6,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 3,
+                                                                column_index: 5,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 4,
+                                                            column_index: 6,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                                ),
+                                Negated(
+                                    Product(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Sum(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Advice {
+                                                    query_index: 4,
+                                                    column_index: 6,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Scaled(
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 10,
+                                        column_index: 10,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            0x2f0f40c2f152a01c9caf66298493d5d0944a041c2e65ba0117c24f76bf8e6483,
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 3,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Fixed {
+                        query_index: 3,
+                        column_index: 4,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Fixed {
+                        query_index: 4,
+                        column_index: 5,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 11,
+                            column_index: 11,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Advice {
+                                query_index: 13,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Fixed {
+                                                query_index: 6,
+                                                column_index: 7,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Product(
+                                                    Fixed {
+                                                        query_index: 6,
+                                                        column_index: 7,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Sum(
+                                                        Fixed {
+                                                            query_index: 6,
+                                                            column_index: 7,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Constant(
+                                                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Advice {
+                                            query_index: 16,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000400,
+                                ),
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Fixed {
+                                query_index: 11,
+                                column_index: 11,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 12,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Scaled(
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 11,
+                                        column_index: 11,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            0x0db5218be6881f0f1431d4ea7d4afc7b29a05bafbede62b55a91eb912044ea5f,
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Fixed {
+                                query_index: 11,
+                                column_index: 11,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 14,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 15,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 11,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 11,
+                                                                column_index: 0,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 1,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                                ),
+                                Negated(
+                                    Product(
+                                        Advice {
+                                            query_index: 14,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Sum(
+                                            Advice {
+                                                query_index: 11,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Advice {
+                                                    query_index: 12,
+                                                    column_index: 1,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Scaled(
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 11,
+                                        column_index: 11,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            0x2f0f40c2f152a01c9caf66298493d5d0944a041c2e65ba0117c24f76bf8e6483,
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 3,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Fixed {
+                        query_index: 3,
+                        column_index: 4,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Fixed {
+                        query_index: 4,
+                        column_index: 5,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+        ],
+        constants: [
+            Column {
+                index: 0,
+                column_type: Fixed,
+            },
+        ],
+        minimum_degree: None,
+    },
+    fixed_commitments: [
+        (0x26b223d8ba8ed483bbbdb8447f9166eb40bd77cc586970213757dceca5b3fe7f, 0x05dd2ed4a2456bd237250d2945d955fb415c841e2545fb0d4a8c937f5f933b61),
+        (0x129d241edb86e5c96fdd9d7beb75bd9a14e7d8592808036c9cf592cfed690b7a, 0x2b54f489a381e59f402ce34abc683b3cec3df0d01377115dc5a143fc9aa09340),
+        (0x17924baebd9681321232d8646f280221f34cd2d87cd125eeadaa974ab4d5dfd0, 0x311b6a25f7169fb1713e5539e10e52a1bdf6767a2fbbbc56d1f5d59a15024efa),
+        (0x05f5862cad2888855bc3c1843a9eff57b11b592d9eb0e13354256661387f5231, 0x32236b14df85bf5f532a930232cb23a5c56ef7d67aaeed8bcb8fc10ea132cbd6),
+        (0x3e727e8554679f98120355d39d958dbd8755d5a7f8b42ea87f258064c4b3eb57, 0x0c0d5c23f3ee62ac1b2d986dd3033bbcab260d590e1393de3a14a4b31ae091bb),
+        (0x3748680dd6a91c5dec668b30fb6bf9a450aeb884b81cbc344914f265760e7131, 0x18530eaa5c58b61bd3fc38220ea484c0922524a815a8f752be955c229f9c4164),
+        (0x03c48d550f56a16644251c9a5dc416e30b29a610010ac7709125782b1607b3e6, 0x3edfa55036455c23093e78530124d2b7778b608a68ab039008e2bd7d438416f0),
+        (0x24fd2ce32655dc5f11fe8e2f9ab780f71a933b9475da27aed0bc3f7f37e29ca1, 0x0cfbb4dc2d19dc3eeecbc1f987c45defa62c0a2a32b601f6eb6305b0b6e3cffa),
+        (0x29290c56da02655ce46b785d7af446f84badffca09b4cbd41e523bc5b7a2b40c, 0x0e8bcdd3843da6764954a9360d7dc02f98408c07b20a15e7e592b54086655ef5),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x2b63c25913a7c51ed52510e22881c2289379dadf144cfaf17cfbd9849ec2593a, 0x07fdeaac027477b02310fbac9575219384101c8c84e67b7be66ab0160f4bea22),
+        (0x109ac97c3d9d86563fd9847eee02f6affa4d788acd9697f2f828248fd6c7c595, 0x3ca254a78e74bfb5bd8144e2af8561b1f9f97d04b64965c0b97bd47cc00a1a1e),
+        (0x159abc8bbb102b81095fe82b2e576d2fd3789725ccad02192867eb6b262a6a8f, 0x1485a4c81a8415340d1571c05b0c99267af41def845f07f7254b87f5f1b056a0),
+        (0x065fa931d37c658c03dea4ad6a87dc06572639527c15c4631a116fd2f2d67062, 0x27765f16048554d160f8e9f1e8f5e285ee71871279b6a83a3060289572cb8844),
+    ],
+    permutation: VerifyingKey {
+        commitments: [
+            (0x12c01814753e91eb23e4606d794078a518c227be4acaff3884f9a9bc9ab40000, 0x3ffeae87fb800669e7a3bda23781a4d16893f0b107382688b56e8f212c84a288),
+            (0x32383e328758decb242d42f75986c1cd5aef9f1a6d6e39c54a53a17630b8a16d, 0x00ae32219df5287e4c3c64ebf0ef83771fad95d67b2f7f3a444f5ede969d1c0c),
+            (0x06c29c2bad49d6ff8dd5669fd563dbe126692880bbeb495d15f810e5acfaa14a, 0x2be470a3fa70893026bb0506aadd32844fae950eefa502111b5806e916007d95),
+            (0x2b32307f41326e8d99a5146ba6aee133ed87d305cd0dd4419e537e2b2028e22a, 0x2334c482571d9f726a0715ae1824965009c5fabd6c3864e996e4ae2020e95c7e),
+            (0x2ebbf8cdb2a64ea5ce464f9439f328e564a02fde4e4f7a8855edcd9c9ef2b2e4, 0x0e73d4cdbe01bff75617a34ddb6fa10c460e3c5556bf4c86230ef54e10a955cf),
+            (0x0f6ecf422fad0e4ff83c6aa5812dc5c36c87d145d5c2e7f40ca6f0c332067826, 0x22b7cb6d58f8f249d6c656cdac28cdfe0c720f4ac1e4fb571a7c4dcd4f3c7bd0),
+            (0x0482e99357c02b25b0e8dd7327b34783dc4459119c0635b5de330d843e277da0, 0x0e30c1696995c9c31d1d179c86b99f2a6f66eaf290765344d2219bfb200f353d),
+            (0x37aba51a64c17ab63e7d76e11ca84ab0aaf7f208fccfd764d27b8b2531046d53, 0x0822915e6a8916334856d07619c7f8862d1c582d651127e9ad81343d9869c5af),
+            (0x2f1e036cc7cf77f6e64cdb1e6cb74dfeff998ec7dbd9ca90d3655db915150641, 0x27b2e33fdd6dd2344bd10c03522af2dbf38cd675c1ef4b23786bccdf8a8cc44a),
+            (0x38a60d928d64f1ef68c137da22be0d1d545c750dc4bb06018f78dbdafe0e32f4, 0x2cdc02d55e4164a17b06994225662703361a6ba56b64c5e5980aae6bd5f18bb1),
+            (0x03b739f9b5f0a3b6093d9d8c7f53068d7dbb5f9dc43ef1871a7bc36dbb0f01d6, 0x2bb4c2c0e642711d11136a9ecfb7bac1d05b400c3a150aeb84bbdb31d01e8c5e),
+        ],
+    },
+}
diff --git a/halo2_gadgets/src/tests/circuit_data/vk_short_range_check_case0.rdata b/halo2_gadgets/src/tests/circuit_data/vk_short_range_check_case0.rdata
new file mode 100644
index 0000000000..6de944cf6c
--- /dev/null
+++ b/halo2_gadgets/src/tests/circuit_data/vk_short_range_check_case0.rdata
@@ -0,0 +1,244 @@
+PinnedVerificationKey {
+    base_modulus: "0x40000000000000000000000000000000224698fc0994a8dd8c46eb2100000001",
+    scalar_modulus: "0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001",
+    domain: PinnedEvaluationDomain {
+        k: 11,
+        extended_k: 14,
+        omega: 0x181b50ad5f32119e31cbd395426d600b7a9b88bcaaa1c24eef28545aada17813,
+    },
+    cs: PinnedConstraintSystem {
+        num_fixed_columns: 5,
+        num_advice_columns: 1,
+        num_instance_columns: 0,
+        num_selectors: 3,
+        gates: [
+            Product(
+                Fixed {
+                    query_index: 4,
+                    column_index: 4,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 2,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    -1,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                        ),
+                        Advice {
+                            query_index: 1,
+                            column_index: 0,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 0,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+        ],
+        advice_queries: [
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+        ],
+        instance_queries: [],
+        fixed_queries: [
+            (
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+        ],
+        permutation: Argument {
+            columns: [
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+            ],
+        },
+        lookups: [
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 2,
+                            column_index: 2,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Product(
+                                Fixed {
+                                    query_index: 3,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 1,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 3,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+        ],
+        constants: [
+            Column {
+                index: 1,
+                column_type: Fixed,
+            },
+        ],
+        minimum_degree: None,
+    },
+    fixed_commitments: [
+        (0x05f5862cad2888855bc3c1843a9eff57b11b592d9eb0e13354256661387f5231, 0x32236b14df85bf5f532a930232cb23a5c56ef7d67aaeed8bcb8fc10ea132cbd6),
+        (0x27c2b8ac34f64d4d18eada2b41dc9d8c30409eb866c7e4d539204fadcb696826, 0x0881a9c2e2e4a577b5a951254bd508dedafa5f1c7be905aaf4fbac60971bc9f7),
+        (0x0980acedb0fd2c02718002125bf80f969175d1f90d1320f9f3d5e2ac584e0212, 0x235c651fefd49e387ef9a6293a428810994974d218c4757ca3f9c0971ae25767),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x28d1c924953bc53f232465943d25fd085f85727ae4e2d26249207da1e59559e2, 0x184d19e00f109c4dacf8026c6e0fc4181178b32a236828047c46d9d61eab90fa),
+    ],
+    permutation: VerifyingKey {
+        commitments: [
+            (0x3b7b93d7540327328791a14933d8f3345abd943eb35b67a8a4bd2eb72e2a707a, 0x26fff57a6fa3c01dd0d739fc56479303b4302d6baa6f1da06f4013419c40e10c),
+            (0x3fdf7a15a0d2378accc11f704f4ba4a487b542ace83c7f5a8551b569a3b9a380, 0x34253920878d15d6fe1b5198c31bdd670d32e81621e9fcd569d582e596ed0af5),
+        ],
+    },
+}
diff --git a/halo2_gadgets/src/tests/circuit_data/vk_short_range_check_case1.rdata b/halo2_gadgets/src/tests/circuit_data/vk_short_range_check_case1.rdata
new file mode 100644
index 0000000000..d17acb3106
--- /dev/null
+++ b/halo2_gadgets/src/tests/circuit_data/vk_short_range_check_case1.rdata
@@ -0,0 +1,244 @@
+PinnedVerificationKey {
+    base_modulus: "0x40000000000000000000000000000000224698fc0994a8dd8c46eb2100000001",
+    scalar_modulus: "0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001",
+    domain: PinnedEvaluationDomain {
+        k: 11,
+        extended_k: 14,
+        omega: 0x181b50ad5f32119e31cbd395426d600b7a9b88bcaaa1c24eef28545aada17813,
+    },
+    cs: PinnedConstraintSystem {
+        num_fixed_columns: 5,
+        num_advice_columns: 1,
+        num_instance_columns: 0,
+        num_selectors: 3,
+        gates: [
+            Product(
+                Fixed {
+                    query_index: 4,
+                    column_index: 4,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 2,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    -1,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                        ),
+                        Advice {
+                            query_index: 1,
+                            column_index: 0,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 0,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+        ],
+        advice_queries: [
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+        ],
+        instance_queries: [],
+        fixed_queries: [
+            (
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+        ],
+        permutation: Argument {
+            columns: [
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+            ],
+        },
+        lookups: [
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 2,
+                            column_index: 2,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Product(
+                                Fixed {
+                                    query_index: 3,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 1,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 3,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+        ],
+        constants: [
+            Column {
+                index: 1,
+                column_type: Fixed,
+            },
+        ],
+        minimum_degree: None,
+    },
+    fixed_commitments: [
+        (0x05f5862cad2888855bc3c1843a9eff57b11b592d9eb0e13354256661387f5231, 0x32236b14df85bf5f532a930232cb23a5c56ef7d67aaeed8bcb8fc10ea132cbd6),
+        (0x369f0b3422178fecf6e9a4fc7224622da26e8b5c74fb9aca5864c9f72e30bd5c, 0x2d7892875c06c460c9c9f66449103e7b6ef2871fb0a4e39b9af90e938c8e291b),
+        (0x0980acedb0fd2c02718002125bf80f969175d1f90d1320f9f3d5e2ac584e0212, 0x235c651fefd49e387ef9a6293a428810994974d218c4757ca3f9c0971ae25767),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x28d1c924953bc53f232465943d25fd085f85727ae4e2d26249207da1e59559e2, 0x184d19e00f109c4dacf8026c6e0fc4181178b32a236828047c46d9d61eab90fa),
+    ],
+    permutation: VerifyingKey {
+        commitments: [
+            (0x3b7b93d7540327328791a14933d8f3345abd943eb35b67a8a4bd2eb72e2a707a, 0x26fff57a6fa3c01dd0d739fc56479303b4302d6baa6f1da06f4013419c40e10c),
+            (0x3fdf7a15a0d2378accc11f704f4ba4a487b542ace83c7f5a8551b569a3b9a380, 0x34253920878d15d6fe1b5198c31bdd670d32e81621e9fcd569d582e596ed0af5),
+        ],
+    },
+}
diff --git a/halo2_gadgets/src/tests/circuit_data/vk_short_range_check_case2.rdata b/halo2_gadgets/src/tests/circuit_data/vk_short_range_check_case2.rdata
new file mode 100644
index 0000000000..8187051b09
--- /dev/null
+++ b/halo2_gadgets/src/tests/circuit_data/vk_short_range_check_case2.rdata
@@ -0,0 +1,244 @@
+PinnedVerificationKey {
+    base_modulus: "0x40000000000000000000000000000000224698fc0994a8dd8c46eb2100000001",
+    scalar_modulus: "0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001",
+    domain: PinnedEvaluationDomain {
+        k: 11,
+        extended_k: 14,
+        omega: 0x181b50ad5f32119e31cbd395426d600b7a9b88bcaaa1c24eef28545aada17813,
+    },
+    cs: PinnedConstraintSystem {
+        num_fixed_columns: 5,
+        num_advice_columns: 1,
+        num_instance_columns: 0,
+        num_selectors: 3,
+        gates: [
+            Product(
+                Fixed {
+                    query_index: 4,
+                    column_index: 4,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 2,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    -1,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                        ),
+                        Advice {
+                            query_index: 1,
+                            column_index: 0,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 0,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+        ],
+        advice_queries: [
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+        ],
+        instance_queries: [],
+        fixed_queries: [
+            (
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+        ],
+        permutation: Argument {
+            columns: [
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+            ],
+        },
+        lookups: [
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 2,
+                            column_index: 2,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Product(
+                                Fixed {
+                                    query_index: 3,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 1,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 3,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+        ],
+        constants: [
+            Column {
+                index: 1,
+                column_type: Fixed,
+            },
+        ],
+        minimum_degree: None,
+    },
+    fixed_commitments: [
+        (0x05f5862cad2888855bc3c1843a9eff57b11b592d9eb0e13354256661387f5231, 0x32236b14df85bf5f532a930232cb23a5c56ef7d67aaeed8bcb8fc10ea132cbd6),
+        (0x2ca6650c6fcad471c1c9d29e9115516064a1fe096af3b13821cf1fe7fee088eb, 0x18e61f68d5978b837a3e2295fe7ae7ca672268a519394f41aabd085aadc1221d),
+        (0x0980acedb0fd2c02718002125bf80f969175d1f90d1320f9f3d5e2ac584e0212, 0x235c651fefd49e387ef9a6293a428810994974d218c4757ca3f9c0971ae25767),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x28d1c924953bc53f232465943d25fd085f85727ae4e2d26249207da1e59559e2, 0x184d19e00f109c4dacf8026c6e0fc4181178b32a236828047c46d9d61eab90fa),
+    ],
+    permutation: VerifyingKey {
+        commitments: [
+            (0x3b7b93d7540327328791a14933d8f3345abd943eb35b67a8a4bd2eb72e2a707a, 0x26fff57a6fa3c01dd0d739fc56479303b4302d6baa6f1da06f4013419c40e10c),
+            (0x3fdf7a15a0d2378accc11f704f4ba4a487b542ace83c7f5a8551b569a3b9a380, 0x34253920878d15d6fe1b5198c31bdd670d32e81621e9fcd569d582e596ed0af5),
+        ],
+    },
+}
diff --git a/halo2_gadgets/src/tests/circuit_data/vk_sinsemilla_chip.rdata b/halo2_gadgets/src/tests/circuit_data/vk_sinsemilla_chip.rdata
new file mode 100644
index 0000000000..1e5ee09d57
--- /dev/null
+++ b/halo2_gadgets/src/tests/circuit_data/vk_sinsemilla_chip.rdata
@@ -0,0 +1,11821 @@
+PinnedVerificationKey {
+    base_modulus: "0x40000000000000000000000000000000224698fc0994a8dd8c46eb2100000001",
+    scalar_modulus: "0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001",
+    domain: PinnedEvaluationDomain {
+        k: 11,
+        extended_k: 14,
+        omega: 0x181b50ad5f32119e31cbd395426d600b7a9b88bcaaa1c24eef28545aada17813,
+    },
+    cs: PinnedConstraintSystem {
+        num_fixed_columns: 25,
+        num_advice_columns: 10,
+        num_instance_columns: 0,
+        num_selectors: 24,
+        gates: [
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 19,
+                                            column_index: 19,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 19,
+                                        column_index: 19,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 19,
+                                column_index: 19,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 2,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    -1,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                        ),
+                        Advice {
+                            query_index: 1,
+                            column_index: 9,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Product(
+                                    Fixed {
+                                        query_index: 19,
+                                        column_index: 19,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                        ),
+                                        Negated(
+                                            Fixed {
+                                                query_index: 19,
+                                                column_index: 19,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000003,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 19,
+                                            column_index: 19,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000004,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 19,
+                                        column_index: 19,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000005,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 3,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Product(
+                                    Fixed {
+                                        query_index: 19,
+                                        column_index: 19,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                        ),
+                                        Negated(
+                                            Fixed {
+                                                query_index: 19,
+                                                column_index: 19,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000003,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 19,
+                                            column_index: 19,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000004,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 19,
+                                        column_index: 19,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000005,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 4,
+                        column_index: 1,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 19,
+                                            column_index: 19,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 19,
+                                        column_index: 19,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 19,
+                                column_index: 19,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 19,
+                                            column_index: 19,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 19,
+                                        column_index: 19,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 19,
+                                column_index: 19,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Product(
+                            Sum(
+                                Sum(
+                                    Advice {
+                                        query_index: 7,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 5,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 5,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 19,
+                                            column_index: 19,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 19,
+                                        column_index: 19,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 19,
+                                column_index: 19,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 8,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 7,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 5,
+                            column_index: 2,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 4,
+                                        column_index: 1,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 5,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Advice {
+                                            query_index: 3,
+                                            column_index: 0,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Product(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Sum(
+                            Sum(
+                                Product(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 7,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Advice {
+                                            query_index: 7,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 8,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Sum(
+                        Sum(
+                            Sum(
+                                Product(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 7,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Advice {
+                                            query_index: 7,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 4,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 8,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 7,
+                            column_index: 2,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 8,
+                            column_index: 3,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 7,
+                            column_index: 2,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 8,
+                            column_index: 3,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Advice {
+                                        query_index: 10,
+                                        column_index: 5,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 4,
+                                        column_index: 1,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 13,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 7,
+                        column_index: 2,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Advice {
+                                        query_index: 10,
+                                        column_index: 5,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 6,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 4,
+                                        column_index: 1,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 13,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 8,
+                        column_index: 3,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 19,
+                                            column_index: 19,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 19,
+                                        column_index: 19,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 19,
+                                    column_index: 19,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 19,
+                                column_index: 19,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 9,
+                        column_index: 4,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Scaled(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 14,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 15,
+                                        column_index: 5,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 8,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Sum(
+                                            Sum(
+                                                Product(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 8,
+                                                        column_index: 3,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 16,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 3,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Advice {
+                            query_index: 16,
+                            column_index: 0,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 4,
+                        column_index: 1,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Advice {
+                            query_index: 17,
+                            column_index: 1,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 2,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 2,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 10,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 6,
+                                                            column_index: 3,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Scaled(
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 2,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 8,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Sum(
+                                Sum(
+                                    Product(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 6,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 8,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 10,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 6,
+                                                            column_index: 3,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Scaled(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 14,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 15,
+                                        column_index: 5,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 8,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Sum(
+                                            Sum(
+                                                Product(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 8,
+                                                        column_index: 3,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 16,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 2,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 2,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 10,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 6,
+                                                            column_index: 3,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Scaled(
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 2,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 8,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Sum(
+                                Sum(
+                                    Product(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 6,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 8,
+                                        column_index: 3,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 10,
+                                            column_index: 5,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 6,
+                                                            column_index: 3,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 14,
+                            column_index: 4,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 20,
+                                        column_index: 20,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 20,
+                                    column_index: 20,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 20,
+                                column_index: 20,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Scaled(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 19,
+                                        column_index: 8,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 7,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Sum(
+                                            Sum(
+                                                Product(
+                                                    Advice {
+                                                        query_index: 19,
+                                                        column_index: 8,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    Advice {
+                                                        query_index: 19,
+                                                        column_index: 8,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 18,
+                                                        column_index: 7,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 16,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 3,
+                        column_index: 0,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Advice {
+                            query_index: 16,
+                            column_index: 0,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 4,
+                        column_index: 1,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Advice {
+                            query_index: 17,
+                            column_index: 1,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 11,
+                            column_index: 6,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 20,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 20,
+                                            column_index: 6,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 13,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 7,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Scaled(
+                                Sum(
+                                    Advice {
+                                        query_index: 11,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 20,
+                                                column_index: 6,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 18,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Sum(
+                                Sum(
+                                    Product(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 12,
+                            column_index: 7,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 7,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Scaled(
+                            Product(
+                                Sum(
+                                    Advice {
+                                        query_index: 19,
+                                        column_index: 8,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 7,
+                                        column_index: 2,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Sum(
+                                            Sum(
+                                                Product(
+                                                    Advice {
+                                                        query_index: 19,
+                                                        column_index: 8,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    Advice {
+                                                        query_index: 19,
+                                                        column_index: 8,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 18,
+                                                        column_index: 7,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 16,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 11,
+                            column_index: 6,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 20,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 11,
+                                    column_index: 6,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 20,
+                                            column_index: 6,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 13,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 7,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Scaled(
+                                Sum(
+                                    Advice {
+                                        query_index: 11,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 20,
+                                                column_index: 6,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Sum(
+                            Product(
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 5,
+                                    column_index: 2,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 18,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Negated(
+                            Sum(
+                                Sum(
+                                    Product(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 12,
+                            column_index: 7,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000003,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Negated(
+                            Scaled(
+                                Product(
+                                    Sum(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Advice {
+                                            query_index: 5,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 12,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Sum(
+                                                Sum(
+                                                    Product(
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Advice {
+                                                            query_index: 13,
+                                                            column_index: 8,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 12,
+                                                            column_index: 7,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 3,
+                                                        column_index: 0,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 19,
+                            column_index: 8,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 1,
+                            column_index: 9,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Product(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Advice {
+                                    query_index: 2,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 1,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                Negated(
+                                    Product(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                        Advice {
+                                            query_index: 2,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                -1,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 1,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Negated(
+                                Product(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                    Advice {
+                                        query_index: 2,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            -1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 0,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 21,
+                                    column_index: 1,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Product(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 1,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Product(
+                                            Constant(
+                                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                                            ),
+                                            Advice {
+                                                query_index: 2,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 0,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 21,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    -1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Product(
+                                Advice {
+                                    query_index: 23,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                Product(
+                                    Constant(
+                                        0x0000000000000000000000000000000010000000000000000000000000000000,
+                                    ),
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000040,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Sum(
+                        Advice {
+                            query_index: 20,
+                            column_index: 6,
+                            rotation: Rotation(
+                                -1,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x00000000000000000000000000000000224698fc0994a8dd8c46eb2100000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 23,
+                        column_index: 7,
+                        rotation: Rotation(
+                            -1,
+                        ),
+                    },
+                    Sum(
+                        Advice {
+                            query_index: 11,
+                            column_index: 6,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Constant(
+                                0x0000000000000000000000000000000010000000000000000000000000000000,
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 23,
+                        column_index: 7,
+                        rotation: Rotation(
+                            -1,
+                        ),
+                    },
+                    Advice {
+                        query_index: 18,
+                        column_index: 7,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 23,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Product(
+                                    Advice {
+                                        query_index: 11,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 22,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                    ),
+                    Advice {
+                        query_index: 18,
+                        column_index: 7,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 1,
+                            column_index: 9,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Scaled(
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 1,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 0,
+                                            column_index: 9,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 1,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 3,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Product(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 1,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 0,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 16,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 21,
+                                            column_index: 21,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 21,
+                                        column_index: 21,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 21,
+                                    column_index: 21,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 21,
+                                column_index: 21,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 1,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                            ),
+                        ),
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Product(
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 1,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 0,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 17,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 22,
+                    column_index: 22,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Constant(
+                                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                ),
+                                                Negated(
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Constant(
+                                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                                            ),
+                                            Negated(
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                                        ),
+                                        Negated(
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000004,
+                                    ),
+                                    Negated(
+                                        Sum(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Scaled(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000005,
+                                ),
+                                Negated(
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Scaled(
+                                                Advice {
+                                                    query_index: 14,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000006,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 14,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000007,
+                        ),
+                        Negated(
+                            Sum(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Scaled(
+                                        Advice {
+                                            query_index: 14,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 22,
+                    column_index: 22,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Sum(
+                            Sum(
+                                Sum(
+                                    Sum(
+                                        Sum(
+                                            Sum(
+                                                Sum(
+                                                    Constant(
+                                                        0x0000000000000000000000000000000000000000000000000000000000000000,
+                                                    ),
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Fixed {
+                                                            query_index: 3,
+                                                            column_index: 2,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Fixed {
+                                                        query_index: 4,
+                                                        column_index: 3,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Fixed {
+                                                    query_index: 5,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Fixed {
+                                                query_index: 6,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Fixed {
+                                            query_index: 7,
+                                            column_index: 6,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Scaled(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Fixed {
+                                        query_index: 8,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Scaled(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Scaled(
+                                                Advice {
+                                                    query_index: 14,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                Fixed {
+                                    query_index: 9,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Product(
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Sum(
+                                                            Advice {
+                                                                query_index: 9,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Negated(
+                                                                Scaled(
+                                                                    Advice {
+                                                                        query_index: 14,
+                                                                        column_index: 4,
+                                                                        rotation: Rotation(
+                                                                            1,
+                                                                        ),
+                                                                    },
+                                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                    Sum(
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Scaled(
+                                                                Advice {
+                                                                    query_index: 14,
+                                                                    column_index: 4,
+                                                                    rotation: Rotation(
+                                                                        1,
+                                                                    ),
+                                                                },
+                                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                                Sum(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Scaled(
+                                                            Advice {
+                                                                query_index: 14,
+                                                                column_index: 4,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                            Sum(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Negated(
+                                                    Scaled(
+                                                        Advice {
+                                                            query_index: 14,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                        0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Scaled(
+                                                    Advice {
+                                                        query_index: 14,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            1,
+                                                        ),
+                                                    },
+                                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Sum(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Negated(
+                                            Scaled(
+                                                Advice {
+                                                    query_index: 14,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        1,
+                                                    ),
+                                                },
+                                                0x0000000000000000000000000000000000000000000000000000000000000008,
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 14,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Fixed {
+                                query_index: 10,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 3,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 22,
+                    column_index: 22,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Fixed {
+                            query_index: 2,
+                            column_index: 12,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 22,
+                    column_index: 22,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 23,
+                    column_index: 23,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Sum(
+                            Sum(
+                                Sum(
+                                    Sum(
+                                        Sum(
+                                            Sum(
+                                                Sum(
+                                                    Constant(
+                                                        0x0000000000000000000000000000000000000000000000000000000000000000,
+                                                    ),
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Fixed {
+                                                            query_index: 3,
+                                                            column_index: 2,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Fixed {
+                                                        query_index: 4,
+                                                        column_index: 3,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Fixed {
+                                                    query_index: 5,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Fixed {
+                                                query_index: 6,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Fixed {
+                                            query_index: 7,
+                                            column_index: 6,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Fixed {
+                                        query_index: 8,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Fixed {
+                                    query_index: 9,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                        Product(
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Product(
+                                                Product(
+                                                    Product(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                        Advice {
+                                                            query_index: 9,
+                                                            column_index: 4,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Fixed {
+                                query_index: 10,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 3,
+                            column_index: 0,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 23,
+                    column_index: 23,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Negated(
+                        Fixed {
+                            query_index: 2,
+                            column_index: 12,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 23,
+                    column_index: 23,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Sum(
+                        Product(
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Negated(
+                            Product(
+                                Product(
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Advice {
+                                        query_index: 3,
+                                        column_index: 0,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000005,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 23,
+                    column_index: 23,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Product(
+                    Product(
+                        Product(
+                            Product(
+                                Product(
+                                    Product(
+                                        Product(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Sum(
+                                                Constant(
+                                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                ),
+                                                Negated(
+                                                    Advice {
+                                                        query_index: 9,
+                                                        column_index: 4,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                        Sum(
+                                            Constant(
+                                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 9,
+                                                    column_index: 4,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000004,
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 9,
+                                            column_index: 4,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000005,
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 9,
+                                        column_index: 4,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000006,
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000007,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 10,
+                        column_index: 5,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Advice {
+                            query_index: 9,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 9,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Sum(
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Negated(
+                            Advice {
+                                query_index: 6,
+                                column_index: 3,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                    Sum(
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 6,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Product(
+                        Advice {
+                            query_index: 9,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 4,
+                            column_index: 1,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Advice {
+                            query_index: 6,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Advice {
+                        query_index: 12,
+                        column_index: 7,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Advice {
+                            query_index: 18,
+                            column_index: 7,
+                            rotation: Rotation(
+                                1,
+                            ),
+                        },
+                        Negated(
+                            Product(
+                                Advice {
+                                    query_index: 24,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        -1,
+                                    ),
+                                },
+                                Constant(
+                                    0x0000000000000000000000000000000001000000000000000000000000000000,
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Product(
+                        Sum(
+                            Advice {
+                                query_index: 19,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    1,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Advice {
+                                        query_index: 18,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    0x0000000000000000000000000000000000000000000000000000000000000008,
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                            ),
+                            Negated(
+                                Sum(
+                                    Advice {
+                                        query_index: 19,
+                                        column_index: 8,
+                                        rotation: Rotation(
+                                            1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 18,
+                                                column_index: 7,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000008,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Advice {
+                        query_index: 22,
+                        column_index: 6,
+                        rotation: Rotation(
+                            1,
+                        ),
+                    },
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Product(
+                        Product(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Advice {
+                                        query_index: 12,
+                                        column_index: 7,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Advice {
+                                    query_index: 12,
+                                    column_index: 7,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Product(
+                    Advice {
+                        query_index: 13,
+                        column_index: 8,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                        ),
+                        Negated(
+                            Advice {
+                                query_index: 13,
+                                column_index: 8,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 24,
+                        column_index: 8,
+                        rotation: Rotation(
+                            -1,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Scaled(
+                                Advice {
+                                    query_index: 13,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                0x0000000000000000000000000000000000000000000000000000000000000004,
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000003,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Advice {
+                        query_index: 11,
+                        column_index: 6,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Negated(
+                        Sum(
+                            Sum(
+                                Sum(
+                                    Advice {
+                                        query_index: 20,
+                                        column_index: 6,
+                                        rotation: Rotation(
+                                            -1,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 24,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    -1,
+                                                ),
+                                            },
+                                            0x1000000000000000000000000000000000000000000000000000000000000000,
+                                        ),
+                                    ),
+                                ),
+                                Constant(
+                                    0x0000000000000000000000000000000400000000000000000000000000000000,
+                                ),
+                            ),
+                            Negated(
+                                Constant(
+                                    0x00000000000000000000000000000000224698fc094cf91b992d30ed00000001,
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Scaled(
+                        Fixed {
+                            query_index: 3,
+                            column_index: 2,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                    ),
+                    Negated(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 6,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 9,
+                                    column_index: 4,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 3,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Sum(
+                                        Sum(
+                                            Product(
+                                                Advice {
+                                                    query_index: 6,
+                                                    column_index: 3,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Advice {
+                                                    query_index: 6,
+                                                    column_index: 3,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 3,
+                                                    column_index: 0,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 4,
+                                                column_index: 1,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 17,
+                    column_index: 17,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Advice {
+                            query_index: 9,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 9,
+                            column_index: 4,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Sum(
+                            Sum(
+                                Advice {
+                                    query_index: 16,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                Sum(
+                                    Sum(
+                                        Product(
+                                            Advice {
+                                                query_index: 6,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 6,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 4,
+                                            column_index: 1,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 17,
+                    column_index: 17,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 9,
+                                column_index: 4,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 3,
+                                column_index: 0,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 16,
+                                    column_index: 0,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Sum(
+                            Sum(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 6,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 6,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 6,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 3,
+                                                                column_index: 0,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 4,
+                                                            column_index: 1,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Product(
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                        Negated(
+                                            Product(
+                                                Fixed {
+                                                    query_index: 11,
+                                                    column_index: 13,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Sum(
+                                                    Fixed {
+                                                        query_index: 11,
+                                                        column_index: 13,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 8,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 14,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 16,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 8,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 8,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 16,
+                                                                column_index: 0,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 17,
+                                                            column_index: 1,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Scaled(
+                                    Product(
+                                        Fixed {
+                                            query_index: 11,
+                                            column_index: 13,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Sum(
+                                            Fixed {
+                                                query_index: 11,
+                                                column_index: 13,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Constant(
+                                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Advice {
+                                    query_index: 8,
+                                    column_index: 3,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Product(
+                    Product(
+                        Product(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 24,
+                                        column_index: 24,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                        ),
+                        Sum(
+                            Constant(
+                                0x0000000000000000000000000000000000000000000000000000000000000002,
+                            ),
+                            Negated(
+                                Fixed {
+                                    query_index: 24,
+                                    column_index: 24,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Constant(
+                            0x0000000000000000000000000000000000000000000000000000000000000003,
+                        ),
+                        Negated(
+                            Fixed {
+                                query_index: 24,
+                                column_index: 24,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+                Sum(
+                    Scaled(
+                        Fixed {
+                            query_index: 4,
+                            column_index: 3,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        0x0000000000000000000000000000000000000000000000000000000000000002,
+                    ),
+                    Negated(
+                        Product(
+                            Sum(
+                                Advice {
+                                    query_index: 13,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                            Sum(
+                                Advice {
+                                    query_index: 10,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Negated(
+                                    Sum(
+                                        Sum(
+                                            Product(
+                                                Advice {
+                                                    query_index: 13,
+                                                    column_index: 8,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Advice {
+                                                    query_index: 13,
+                                                    column_index: 8,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            Negated(
+                                                Advice {
+                                                    query_index: 10,
+                                                    column_index: 5,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 11,
+                                                column_index: 6,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 18,
+                    column_index: 18,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Advice {
+                            query_index: 0,
+                            column_index: 9,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                    ),
+                    Negated(
+                        Sum(
+                            Sum(
+                                Advice {
+                                    query_index: 15,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                                Sum(
+                                    Sum(
+                                        Product(
+                                            Advice {
+                                                query_index: 13,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 13,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Negated(
+                                            Advice {
+                                                query_index: 10,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                    ),
+                                    Negated(
+                                        Advice {
+                                            query_index: 11,
+                                            column_index: 6,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            ),
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                    ),
+                ),
+            ),
+            Product(
+                Fixed {
+                    query_index: 18,
+                    column_index: 18,
+                    rotation: Rotation(
+                        0,
+                    ),
+                },
+                Sum(
+                    Product(
+                        Scaled(
+                            Advice {
+                                query_index: 0,
+                                column_index: 9,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            0x0000000000000000000000000000000000000000000000000000000000000004,
+                        ),
+                        Sum(
+                            Advice {
+                                query_index: 10,
+                                column_index: 5,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Advice {
+                                    query_index: 15,
+                                    column_index: 5,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                    Negated(
+                        Sum(
+                            Sum(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 13,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 0,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 10,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 13,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 13,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 10,
+                                                                column_index: 5,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 11,
+                                                            column_index: 6,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Product(
+                                    Sum(
+                                        Constant(
+                                            0x0000000000000000000000000000000000000000000000000000000000000002,
+                                        ),
+                                        Negated(
+                                            Product(
+                                                Fixed {
+                                                    query_index: 14,
+                                                    column_index: 14,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                                Sum(
+                                                    Fixed {
+                                                        query_index: 14,
+                                                        column_index: 14,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Negated(
+                                                        Constant(
+                                                            0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 19,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 1,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 15,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 19,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 19,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 15,
+                                                                column_index: 5,
+                                                                rotation: Rotation(
+                                                                    1,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 22,
+                                                            column_index: 6,
+                                                            rotation: Rotation(
+                                                                1,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Scaled(
+                                    Product(
+                                        Fixed {
+                                            query_index: 14,
+                                            column_index: 14,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Sum(
+                                            Fixed {
+                                                query_index: 14,
+                                                column_index: 14,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Constant(
+                                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000002,
+                                ),
+                                Advice {
+                                    query_index: 19,
+                                    column_index: 8,
+                                    rotation: Rotation(
+                                        1,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ],
+        advice_queries: [
+            (
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 5,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 5,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Rotation(
+                    1,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Rotation(
+                    -1,
+                ),
+            ),
+        ],
+        instance_queries: [],
+        fixed_queries: [
+            (
+                Column {
+                    index: 0,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 1,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 12,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 2,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 3,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 4,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 5,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 6,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 7,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 8,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 9,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 13,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 10,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 11,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 14,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 15,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 16,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 17,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 18,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 19,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 20,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 21,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 22,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 23,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+            (
+                Column {
+                    index: 24,
+                    column_type: Fixed,
+                },
+                Rotation(
+                    0,
+                ),
+            ),
+        ],
+        permutation: Argument {
+            columns: [
+                Column {
+                    index: 0,
+                    column_type: Fixed,
+                },
+                Column {
+                    index: 9,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 0,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 1,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 2,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 3,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 4,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 6,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 8,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 7,
+                    column_type: Advice,
+                },
+                Column {
+                    index: 5,
+                    column_type: Advice,
+                },
+            ],
+        },
+        lookups: [
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 15,
+                            column_index: 15,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Product(
+                                Fixed {
+                                    query_index: 16,
+                                    column_index: 16,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                                Sum(
+                                    Advice {
+                                        query_index: 0,
+                                        column_index: 9,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                    Negated(
+                                        Scaled(
+                                            Advice {
+                                                query_index: 1,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    1,
+                                                ),
+                                            },
+                                            0x0000000000000000000000000000000000000000000000000000000000000400,
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            Product(
+                                Sum(
+                                    Constant(
+                                        0x0000000000000000000000000000000000000000000000000000000000000001,
+                                    ),
+                                    Negated(
+                                        Fixed {
+                                            query_index: 16,
+                                            column_index: 16,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                                Advice {
+                                    query_index: 0,
+                                    column_index: 9,
+                                    rotation: Rotation(
+                                        0,
+                                    ),
+                                },
+                            ),
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 1,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 17,
+                            column_index: 17,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Advice {
+                                query_index: 5,
+                                column_index: 2,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Fixed {
+                                                query_index: 11,
+                                                column_index: 13,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Product(
+                                                    Fixed {
+                                                        query_index: 11,
+                                                        column_index: 13,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Sum(
+                                                        Fixed {
+                                                            query_index: 11,
+                                                            column_index: 13,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Constant(
+                                                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Advice {
+                                            query_index: 7,
+                                            column_index: 2,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000400,
+                                ),
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Fixed {
+                                query_index: 17,
+                                column_index: 17,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 4,
+                                column_index: 1,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Scaled(
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 17,
+                                        column_index: 17,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            0x0db5218be6881f0f1431d4ea7d4afc7b29a05bafbede62b55a91eb912044ea5f,
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Fixed {
+                                query_index: 17,
+                                column_index: 17,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 6,
+                                                column_index: 3,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 9,
+                                                column_index: 4,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 6,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 6,
+                                                                column_index: 3,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 3,
+                                                                column_index: 0,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 4,
+                                                            column_index: 1,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                                ),
+                                Negated(
+                                    Product(
+                                        Advice {
+                                            query_index: 6,
+                                            column_index: 3,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Sum(
+                                            Advice {
+                                                query_index: 3,
+                                                column_index: 0,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Advice {
+                                                    query_index: 4,
+                                                    column_index: 1,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Scaled(
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 17,
+                                        column_index: 17,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            0x2f0f40c2f152a01c9caf66298493d5d0944a041c2e65ba0117c24f76bf8e6483,
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 1,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Fixed {
+                        query_index: 12,
+                        column_index: 10,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Fixed {
+                        query_index: 13,
+                        column_index: 11,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+            Argument {
+                input_expressions: [
+                    Product(
+                        Fixed {
+                            query_index: 18,
+                            column_index: 18,
+                            rotation: Rotation(
+                                0,
+                            ),
+                        },
+                        Sum(
+                            Advice {
+                                query_index: 12,
+                                column_index: 7,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Negated(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Fixed {
+                                                query_index: 14,
+                                                column_index: 14,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Product(
+                                                    Fixed {
+                                                        query_index: 14,
+                                                        column_index: 14,
+                                                        rotation: Rotation(
+                                                            0,
+                                                        ),
+                                                    },
+                                                    Sum(
+                                                        Fixed {
+                                                            query_index: 14,
+                                                            column_index: 14,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                        Negated(
+                                                            Constant(
+                                                                0x0000000000000000000000000000000000000000000000000000000000000001,
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                        Advice {
+                                            query_index: 18,
+                                            column_index: 7,
+                                            rotation: Rotation(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                    0x0000000000000000000000000000000000000000000000000000000000000400,
+                                ),
+                            ),
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Advice {
+                                query_index: 11,
+                                column_index: 6,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                        ),
+                        Scaled(
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 18,
+                                        column_index: 18,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            0x0db5218be6881f0f1431d4ea7d4afc7b29a05bafbede62b55a91eb912044ea5f,
+                        ),
+                    ),
+                    Sum(
+                        Product(
+                            Fixed {
+                                query_index: 18,
+                                column_index: 18,
+                                rotation: Rotation(
+                                    0,
+                                ),
+                            },
+                            Sum(
+                                Scaled(
+                                    Product(
+                                        Sum(
+                                            Advice {
+                                                query_index: 13,
+                                                column_index: 8,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Advice {
+                                                query_index: 0,
+                                                column_index: 9,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                        ),
+                                        Sum(
+                                            Advice {
+                                                query_index: 10,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Sum(
+                                                    Sum(
+                                                        Product(
+                                                            Advice {
+                                                                query_index: 13,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                            Advice {
+                                                                query_index: 13,
+                                                                column_index: 8,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                        Negated(
+                                                            Advice {
+                                                                query_index: 10,
+                                                                column_index: 5,
+                                                                rotation: Rotation(
+                                                                    0,
+                                                                ),
+                                                            },
+                                                        ),
+                                                    ),
+                                                    Negated(
+                                                        Advice {
+                                                            query_index: 11,
+                                                            column_index: 6,
+                                                            rotation: Rotation(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                    0x2000000000000000000000000000000011234c7e04a67c8dcc96987680000001,
+                                ),
+                                Negated(
+                                    Product(
+                                        Advice {
+                                            query_index: 13,
+                                            column_index: 8,
+                                            rotation: Rotation(
+                                                0,
+                                            ),
+                                        },
+                                        Sum(
+                                            Advice {
+                                                query_index: 10,
+                                                column_index: 5,
+                                                rotation: Rotation(
+                                                    0,
+                                                ),
+                                            },
+                                            Negated(
+                                                Advice {
+                                                    query_index: 11,
+                                                    column_index: 6,
+                                                    rotation: Rotation(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        Scaled(
+                            Sum(
+                                Constant(
+                                    0x0000000000000000000000000000000000000000000000000000000000000001,
+                                ),
+                                Negated(
+                                    Fixed {
+                                        query_index: 18,
+                                        column_index: 18,
+                                        rotation: Rotation(
+                                            0,
+                                        ),
+                                    },
+                                ),
+                            ),
+                            0x2f0f40c2f152a01c9caf66298493d5d0944a041c2e65ba0117c24f76bf8e6483,
+                        ),
+                    ),
+                ],
+                table_expressions: [
+                    Fixed {
+                        query_index: 1,
+                        column_index: 1,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Fixed {
+                        query_index: 12,
+                        column_index: 10,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                    Fixed {
+                        query_index: 13,
+                        column_index: 11,
+                        rotation: Rotation(
+                            0,
+                        ),
+                    },
+                ],
+            },
+        ],
+        constants: [
+            Column {
+                index: 0,
+                column_type: Fixed,
+            },
+        ],
+        minimum_degree: None,
+    },
+    fixed_commitments: [
+        (0x372e1011c41715c062e0bdb944973af06c5e779e64d2eb64b713ba7a923bd921, 0x0df587dbf80715f2e1a3429e4970dc1ee2b4478ac56fc6308bd1423a96630eff),
+        (0x05f5862cad2888855bc3c1843a9eff57b11b592d9eb0e13354256661387f5231, 0x32236b14df85bf5f532a930232cb23a5c56ef7d67aaeed8bcb8fc10ea132cbd6),
+        (0x278ceb78d7e41109f04648e31a17d363250264779a54822b6af849e08394f8c6, 0x38657e78f288108b1eabf5752c294db179397f61b34e3bcce8b9ea64f0414ccf),
+        (0x02f77b8037894d3be78b9913b56f87a4a11de5b23a2715653c95284f5f4a533a, 0x21f3437bc1226236ea0b87217af56ccca66daa8641dfa562c1bac1c9c97e9ba3),
+        (0x226cbe263518a231a03864a40070593012418e4adaad26a9657068c92bd99834, 0x30aa25907ea9e3751193ca7a4d1e25c1f085f07e24fa55790d8dde572cbb4b39),
+        (0x31bb1ac8ad43e9c13b44aec205cedd51ba49044f42b9778a281c8f78499c5844, 0x0d10aa271191e573188ce755174183966f97996f460a32129f409c6e33452859),
+        (0x3cafd5ce5d34b1e0318cc5b0e655cc0411dd86d2c917c4c776923920ce4b8783, 0x1cec31e481cd980c231475d95ce7595a241d33128f0d0f556fa3e3ce64309182),
+        (0x17749546b03083d43554511e69f5f2049e78c7893f4c6012a44e51f0e8ed314a, 0x39347f6d9fc4dd61e475a277ce7dfb0e4d1d31e1c0a10d8bbe6b4029cb778964),
+        (0x31d60c414c7acf6d5941cf201088d51eb81e528ffefa458f2fccea9d81ad274b, 0x3aa09ba345b10e2ff005c50f5d1fb5b86a7145c2f744cadac9567fde1e4e1b17),
+        (0x1de5f02daa9e1bd92e54a37fd41969e14c89c09b718a791f616c0de7c51eea94, 0x096456cd7e00ab2d318dd5d38ef0b918faff5225d8dc34e1fe3c2db4ef5698bb),
+        (0x3e727e8554679f98120355d39d958dbd8755d5a7f8b42ea87f258064c4b3eb57, 0x0c0d5c23f3ee62ac1b2d986dd3033bbcab260d590e1393de3a14a4b31ae091bb),
+        (0x3748680dd6a91c5dec668b30fb6bf9a450aeb884b81cbc344914f265760e7131, 0x18530eaa5c58b61bd3fc38220ea484c0922524a815a8f752be955c229f9c4164),
+        (0x2fa9bff8025b9eb1fd60c0bec845d6d09c49a03d7020280feae9751acb88bdb6, 0x0958e83ae406bdc3c0704afa316f3717568c74cc4475127443a6c9058444234c),
+        (0x2f39f6d3b0dd8e900034e38670e853e761825dff78c4060e2ca4832ecb1de86a, 0x13c40f0fe6243ac40fb8abbcf7e62f027362a8e0b65b38f7657dc4db3e471fdc),
+        (0x0fc9e35a206e0ecd68eb1aa156be11067d48cb853f8b7be8366e693077c05adc, 0x0f2d1e728e41ca4cdf33998fcf2b9ff442523b2d854ea7b800cc79ef381ef053),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x0132c6f79957c48e8e89c8bb06a02b1ab2fa2872c6bbf2a98d24ae2cf286ab65, 0x101570d65833ffd44e4a481f7f2c0b42854b2785beebe0f3e3e7cf0432b0f2a8),
+        (0x1bb21f71d0d3cf31cc7604e6c80f219a95ad8a2fdda1ba4749038a850cb295e5, 0x21fbf3282559a16f747df709bb6e53ae247bf4aefdef22d1456ceee0069a5a30),
+        (0x298e4558e567ccac97873d2423022d66ccaf4330fe3a168a283fe38c36ded7cf, 0x2a19cc559c589cd3dce09b37b01d147351e5629d81aa067a92564bbab3264606),
+        (0x25fdb5e53d333b73513af137b20e1ff8556ba3528f8421dc94fff7993c2825fc, 0x1dd77006ac8a5883fc101e9869119f58702ecd6ba2248d6fe887dec9a9cb7abe),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x2bbc94ef7b22aebef24f9a4b0cc1831882548b605171366017d45c3e6fd92075, 0x082b801a6e176239943bfb759fb02138f47a5c8cc4aa7fa0af559fde4e3abd97),
+        (0x1807fc6a973fabd4cfdb43133ab368dc3ec8b3e3c49a33022ceb7a11312994a9, 0x090fa9b27aad0b2466a0fe73bc6e27b071522f808223697e06a97b0067a295d9),
+        (0x09899c24004863d99205b3e8d12091fb9efc7f869213aabfa755ce8226296ac8, 0x3b9fd993ade2b56baa51cb480372188b2b4a6c029721abd78f882376a2e1066f),
+    ],
+    permutation: VerifyingKey {
+        commitments: [
+            (0x19b1e656ecc4bcddac6e6223161f9a676f6dc320323dd923d07b107bd956980f, 0x12b19731c6cf97867694f17f8241ae4f87699babe1f2e0aff0da5843c495687c),
+            (0x34015e25137a9a8ea4feb8af77f10d27fc6a04e952823f7e2343a749419df2ce, 0x2c6589a5343037dd14d33821800626bba96354283fb05011f27dcda6a6b860fb),
+            (0x3b99cb11670a52fb09cdb23f99dec85dd61bfee1120cb6cb7f976a027e7fe29d, 0x147c5a63bed5b0a16b5f28c68ccc46bb175a71f093c1a14e71c944ca20d2d5a8),
+            (0x0447bb1bd9cd21264decdcf1d3d8c51152dde3e2973c289636c5143fee588597, 0x2693688ea58e92c734de32906f8646d3e7eb92df37eab9e95f8e1fa0fb47740c),
+            (0x139a2e45b57a51ef2b2f091026e534e710f4095a248e029411c83545ffbe980a, 0x3a9f5a5f1778dc3ab162ba7e408f8787deccc79eed79f39ba8e95d30d59bf072),
+            (0x3bb81950a72eed5a0d778f649dcfdebbc7fd777c40ebbc8423a5359b1657ec69, 0x0827061e9cb496f1de9b65eb40414b801f1cab7ea1451db61b26d8828db12934),
+            (0x053904bdde8cfead3b517bb4f6ded3e699f8b94ca6156a9dd2f92a2a05a7ec5a, 0x16753ff97c0d82ff586bb7a07bf7f27a92df90b3617fa5e75d4f55c3b0ef8711),
+            (0x3804548f6816452747a5b542fa5656353fc989db40d69e9e27d6f973b5deebb0, 0x389a44d5037866dd83993af75831a5f90a18ad5244255aa5bd2c922cc5853055),
+            (0x1364aec73f61f3bbef067b079769ef911ef829c7bc96aad03eb7f67f5267f7a2, 0x2286218435feaff751a5b11ffcad519cce178967d265737fce47b4ce2bbf3855),
+            (0x0c789966ab89d6e03049ae4d06a58aad553df983f7feaf75568ef95e477d8a48, 0x16786ba48d94e3c7968ea059eb9ce4db1684a7804d886a586bb691dca1646754),
+            (0x16633696ce5a30d1d301ceaab86aad90ea6ea22adf090e31859b4fb571e9b746, 0x035966e0a73b53474ee433e2f835e1a8b02c29a49f109bdd590a37d2b946dd03),
+        ],
+    },
+}
diff --git a/halo2_gadgets/src/tests/test_utils.rs b/halo2_gadgets/src/tests/test_utils.rs
new file mode 100644
index 0000000000..8ee5224cd5
--- /dev/null
+++ b/halo2_gadgets/src/tests/test_utils.rs
@@ -0,0 +1,114 @@
+//! Functions used for circuit test.
+
+use std::{env, fs, path::Path};
+
+use rand::rngs::OsRng;
+
+use pasta_curves::{
+    vesta::Affine,
+    {pallas, vesta},
+};
+
+use halo2_proofs::{
+    plonk::{
+        self, {Circuit, SingleVerifier, VerifyingKey},
+    },
+    poly::commitment::Params,
+    transcript::{Blake2bRead, Blake2bWrite},
+};
+
+const TEST_DATA_DIR: &str = "src/tests/circuit_data";
+const GEN_ENV_VAR: &str = "CIRCUIT_TEST_GENERATE_NEW_DATA";
+
+#[derive(Clone, Debug)]
+pub struct Proof(Vec<u8>);
+
+impl AsRef<[u8]> for Proof {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl Proof {
+    /// Creates a proof for the given circuit and instances.
+    pub fn create<C>(
+        vk: &VerifyingKey<Affine>,
+        params: &Params<Affine>,
+        circuit: C,
+    ) -> Result<Self, plonk::Error>
+    where
+        C: Circuit<pallas::Base>,
+    {
+        let pk = plonk::keygen_pk(params, vk.clone(), &circuit).unwrap();
+
+        let mut transcript = Blake2bWrite::<_, vesta::Affine, _>::init(vec![]);
+        plonk::create_proof(params, &pk, &[circuit], &[&[]], OsRng, &mut transcript)?;
+        let proof = transcript.finalize();
+
+        Ok(Proof(proof))
+    }
+
+    /// Verifies this proof with the instances.
+    pub fn verify(
+        &self,
+        vk: &VerifyingKey<Affine>,
+        params: &Params<Affine>,
+    ) -> Result<(), plonk::Error> {
+        let strategy = SingleVerifier::new(params);
+        let mut transcript = Blake2bRead::init(&self.0[..]);
+        plonk::verify_proof(params, vk, strategy, &[&[]], &mut transcript)
+    }
+
+    /// Constructs a new Proof value.
+    pub fn new(bytes: Vec<u8>) -> Self {
+        Proof(bytes)
+    }
+}
+
+/// Test the generated vk and the generated proof against the stored vk and the stored proof.
+///
+/// If the env variable GEN_ENV_VAR is set, save `vk` and `proof` into a file.
+pub(crate) fn test_against_stored_circuit<C: Circuit<pallas::Base>>(
+    circuit: C,
+    circuit_name: &str,
+    expected_proof_size: usize,
+) {
+    let vk_file_path = Path::new(TEST_DATA_DIR)
+        .join(format!("vk_{circuit_name}"))
+        .with_extension("rdata");
+
+    // Setup phase: generate parameters, vk for the circuit.
+    let params: Params<Affine> = Params::new(11);
+    let vk = plonk::keygen_vk(&params, &circuit).unwrap();
+
+    let vk_text = format!("{:#?}\n", vk.pinned());
+
+    if env::var_os(GEN_ENV_VAR).is_some() {
+        fs::write(&vk_file_path, &vk_text).expect("Unable to write vk test file");
+    } else {
+        assert_eq!(
+            vk_text,
+            fs::read_to_string(vk_file_path)
+                .expect("Unable to read vk test file")
+                .replace("\r\n", "\n")
+        );
+    }
+
+    let proof_file_path = Path::new(TEST_DATA_DIR)
+        .join(format!("proof_{circuit_name}"))
+        .with_extension("bin");
+
+    let proof = if env::var_os(GEN_ENV_VAR).is_some() {
+        // Create the proof and save it into a file
+        let proof = Proof::create(&vk, &params, circuit).unwrap();
+        fs::write(&proof_file_path, proof.as_ref()).expect("Unable to write proof test file");
+        proof
+    } else {
+        // Read the proof from storage
+        Proof::new(fs::read(proof_file_path).expect("Unable to read proof test file"))
+    };
+
+    // Verify the stored proof with the generated or stored vk.
+    assert!(proof.verify(&vk, &params).is_ok());
+    assert_eq!(proof.0.len(), expected_proof_size);
+}
diff --git a/halo2_gadgets/src/utilities/lookup_range_check.rs b/halo2_gadgets/src/utilities/lookup_range_check.rs
index b26a89a884..7e38b0737a 100644
--- a/halo2_gadgets/src/utilities/lookup_range_check.rs
+++ b/halo2_gadgets/src/utilities/lookup_range_check.rs
@@ -6,10 +6,14 @@ use halo2_proofs::{
     plonk::{Advice, Column, ConstraintSystem, Constraints, Error, Selector, TableColumn},
     poly::Rotation,
 };
-use std::{convert::TryInto, marker::PhantomData};
+use std::{convert::TryInto, fmt::Debug, marker::PhantomData};
 
 use ff::PrimeFieldBits;
 
+use pasta_curves::pallas;
+
+use crate::sinsemilla::primitives as sinsemilla;
+
 use super::*;
 
 /// The running sum $[z_0, ..., z_W]$. If created in strict mode, $z_W = 0$.
@@ -30,8 +34,8 @@ impl<F: PrimeFieldBits> RangeConstrained<F, AssignedCell<F, F>> {
     /// # Panics
     ///
     /// Panics if `bitrange.len() >= K`.
-    pub fn witness_short<const K: usize>(
-        lookup_config: &LookupRangeCheckConfig<F, K>,
+    pub fn witness_short<const K: usize, Lookup: LookupRangeCheck<F, K>>(
+        lookup_config: &Lookup,
         layouter: impl Layouter<F>,
         value: Value<&F>,
         bitrange: Range<usize>,
@@ -54,7 +58,7 @@ impl<F: PrimeFieldBits> RangeConstrained<F, AssignedCell<F, F>> {
     }
 }
 
-/// Configuration that provides methods for a lookup range check.
+/// Configuration that provides methods for a 10-bit lookup range check.
 #[derive(Eq, PartialEq, Debug, Clone, Copy)]
 pub struct LookupRangeCheckConfig<F: PrimeFieldBits, const K: usize> {
     q_lookup: Selector,
@@ -65,7 +69,11 @@ pub struct LookupRangeCheckConfig<F: PrimeFieldBits, const K: usize> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
+/// Trait that provides common methods for a lookup range check.
+pub trait LookupRangeCheck<F: PrimeFieldBits, const K: usize> {
+    /// Returns a reference to the `LookupRangeCheckConfig` instance.
+    fn config(&self) -> &LookupRangeCheckConfig<F, K>;
+
     /// The `running_sum` advice column breaks the field element into `K`-bit
     /// words. It is used to construct the input expression to the lookup
     /// argument.
@@ -77,107 +85,35 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
     /// # Side-effects
     ///
     /// Both the `running_sum` and `constants` columns will be equality-enabled.
-    pub fn configure(
+    fn configure(
         meta: &mut ConstraintSystem<F>,
         running_sum: Column<Advice>,
         table_idx: TableColumn,
-    ) -> Self {
-        meta.enable_equality(running_sum);
-
-        let q_lookup = meta.complex_selector();
-        let q_running = meta.complex_selector();
-        let q_bitshift = meta.selector();
-        let config = LookupRangeCheckConfig {
-            q_lookup,
-            q_running,
-            q_bitshift,
-            running_sum,
-            table_idx,
-            _marker: PhantomData,
-        };
-
-        // https://p.z.cash/halo2-0.1:decompose-combined-lookup
-        meta.lookup(|meta| {
-            let q_lookup = meta.query_selector(config.q_lookup);
-            let q_running = meta.query_selector(config.q_running);
-            let z_cur = meta.query_advice(config.running_sum, Rotation::cur());
-
-            // In the case of a running sum decomposition, we recover the word from
-            // the difference of the running sums:
-            //    z_i = 2^{K}⋅z_{i + 1} + a_i
-            // => a_i = z_i - 2^{K}⋅z_{i + 1}
-            let running_sum_lookup = {
-                let running_sum_word = {
-                    let z_next = meta.query_advice(config.running_sum, Rotation::next());
-                    z_cur.clone() - z_next * F::from(1 << K)
-                };
-
-                q_running.clone() * running_sum_word
-            };
-
-            // In the short range check, the word is directly witnessed.
-            let short_lookup = {
-                let short_word = z_cur;
-                let q_short = Expression::Constant(F::ONE) - q_running;
-
-                q_short * short_word
-            };
-
-            // Combine the running sum and short lookups:
-            vec![(
-                q_lookup * (running_sum_lookup + short_lookup),
-                config.table_idx,
-            )]
-        });
-
-        // For short lookups, check that the word has been shifted by the correct number of bits.
-        // https://p.z.cash/halo2-0.1:decompose-short-lookup
-        meta.create_gate("Short lookup bitshift", |meta| {
-            let q_bitshift = meta.query_selector(config.q_bitshift);
-            let word = meta.query_advice(config.running_sum, Rotation::prev());
-            let shifted_word = meta.query_advice(config.running_sum, Rotation::cur());
-            let inv_two_pow_s = meta.query_advice(config.running_sum, Rotation::next());
-
-            let two_pow_k = F::from(1 << K);
-
-            // shifted_word = word * 2^{K-s}
-            //              = word * 2^K * inv_two_pow_s
-            Constraints::with_selector(
-                q_bitshift,
-                Some(word * two_pow_k * inv_two_pow_s - shifted_word),
-            )
-        });
-
-        config
-    }
+    ) -> Self
+    where
+        Self: Sized;
 
     #[cfg(test)]
-    // Loads the values [0..2^K) into `table_idx`. This is only used in testing
-    // for now, since the Sinsemilla chip provides a pre-loaded table in the
-    // Orchard context.
-    pub fn load(&self, layouter: &mut impl Layouter<F>) -> Result<(), Error> {
-        layouter.assign_table(
-            || "table_idx",
-            |mut table| {
-                // We generate the row values lazily (we only need them during keygen).
-                for index in 0..(1 << K) {
-                    table.assign_cell(
-                        || "table_idx",
-                        self.table_idx,
-                        index,
-                        || Value::known(F::from(index as u64)),
-                    )?;
-                }
-                Ok(())
-            },
-        )
-    }
+    // Fill `table_idx` and `table_range_check_tag`.
+    // This is only used in testing for now, since the Sinsemilla chip provides a pre-loaded table
+    // in the Orchard context.
+    fn load(&self, layouter: &mut impl Layouter<F>) -> Result<(), Error>;
+
+    /// Constrain `x` to be a NUM_BITS word.
+    ///
+    /// `element` must have been assigned to `self.running_sum` at offset 0.
+    fn short_range_check(
+        &self,
+        region: &mut Region<'_, F>,
+        element: AssignedCell<F, F>,
+        num_bits: usize,
+    ) -> Result<(), Error>;
 
     /// Range check on an existing cell that is copied into this helper.
     ///
     /// Returns an error if `element` is not in a column that was passed to
     /// [`ConstraintSystem::enable_equality`] during circuit configuration.
-    pub fn copy_check(
+    fn copy_check(
         &self,
         mut layouter: impl Layouter<F>,
         element: AssignedCell<F, F>,
@@ -188,14 +124,15 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
             || format!("{:?} words range check", num_words),
             |mut region| {
                 // Copy `element` and initialize running sum `z_0 = element` to decompose it.
-                let z_0 = element.copy_advice(|| "z_0", &mut region, self.running_sum, 0)?;
+                let z_0 =
+                    element.copy_advice(|| "z_0", &mut region, self.config().running_sum, 0)?;
                 self.range_check(&mut region, z_0, num_words, strict)
             },
         )
     }
 
     /// Range check on a value that is witnessed in this helper.
-    pub fn witness_check(
+    fn witness_check(
         &self,
         mut layouter: impl Layouter<F>,
         value: Value<F>,
@@ -205,8 +142,12 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
         layouter.assign_region(
             || "Witness element",
             |mut region| {
-                let z_0 =
-                    region.assign_advice(|| "Witness element", self.running_sum, 0, || value)?;
+                let z_0 = region.assign_advice(
+                    || "Witness element",
+                    self.config().running_sum,
+                    0,
+                    || value,
+                )?;
                 self.range_check(&mut region, z_0, num_words, strict)
             },
         )
@@ -261,9 +202,9 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
         let inv_two_pow_k = F::from(1u64 << K).invert().unwrap();
         for (idx, word) in words.iter().enumerate() {
             // Enable q_lookup on this row
-            self.q_lookup.enable(region, idx)?;
+            self.config().q_lookup.enable(region, idx)?;
             // Enable q_running on this row
-            self.q_running.enable(region, idx)?;
+            self.config().q_running.enable(region, idx)?;
 
             // z_next = (z_cur - m_cur) / 2^K
             z = {
@@ -275,7 +216,7 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
                 // Assign z_next
                 region.assign_advice(
                     || format!("z_{:?}", idx + 1),
-                    self.running_sum,
+                    self.config().running_sum,
                     idx + 1,
                     || z_val,
                 )?
@@ -296,7 +237,7 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
     /// # Panics
     ///
     /// Panics if NUM_BITS is equal to or larger than K.
-    pub fn copy_short_check(
+    fn copy_short_check(
         &self,
         mut layouter: impl Layouter<F>,
         element: AssignedCell<F, F>,
@@ -308,8 +249,7 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
             |mut region| {
                 // Copy `element` to use in the k-bit lookup.
                 let element =
-                    element.copy_advice(|| "element", &mut region, self.running_sum, 0)?;
-
+                    element.copy_advice(|| "element", &mut region, self.config().running_sum, 0)?;
                 self.short_range_check(&mut region, element, num_bits)
             },
         )
@@ -320,7 +260,7 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
     /// # Panics
     ///
     /// Panics if num_bits is larger than K.
-    pub fn witness_short_check(
+    fn witness_short_check(
         &self,
         mut layouter: impl Layouter<F>,
         element: Value<F>,
@@ -331,8 +271,12 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
             || format!("Range check {:?} bits", num_bits),
             |mut region| {
                 // Witness `element` to use in the k-bit lookup.
-                let element =
-                    region.assign_advice(|| "Witness element", self.running_sum, 0, || element)?;
+                let element = region.assign_advice(
+                    || "Witness element",
+                    self.config().running_sum,
+                    0,
+                    || element,
+                )?;
 
                 self.short_range_check(&mut region, element.clone(), num_bits)?;
 
@@ -340,6 +284,122 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
             },
         )
     }
+}
+
+impl<F: PrimeFieldBits, const K: usize> LookupRangeCheck<F, K> for LookupRangeCheckConfig<F, K> {
+    fn config(&self) -> &LookupRangeCheckConfig<F, K> {
+        self
+    }
+
+    /// The `running_sum` advice column breaks the field element into `K`-bit
+    /// words. It is used to construct the input expression to the lookup
+    /// argument.
+    ///
+    /// The `table_idx` fixed column contains values from [0..2^K). Looking up
+    /// a value in `table_idx` constrains it to be within this range. The table
+    /// can be loaded outside this helper.
+    ///
+    /// # Side-effects
+    ///
+    /// Both the `running_sum` and `constants` columns will be equality-enabled.
+    fn configure(
+        meta: &mut ConstraintSystem<F>,
+        running_sum: Column<Advice>,
+        table_idx: TableColumn,
+    ) -> Self {
+        meta.enable_equality(running_sum);
+
+        let q_lookup = meta.complex_selector();
+        let q_running = meta.complex_selector();
+        let q_bitshift = meta.selector();
+
+        // if the order of the creation makes a difference
+        let config = LookupRangeCheckConfig {
+            q_lookup,
+            q_running,
+            q_bitshift,
+            running_sum,
+            table_idx,
+            _marker: PhantomData,
+        };
+
+        // https://p.z.cash/halo2-0.1:decompose-combined-lookup
+        meta.lookup(|meta| {
+            let q_lookup = meta.query_selector(config.q_lookup);
+            let q_running = meta.query_selector(config.q_running);
+            // if the order of the creation makes a difference
+            let z_cur = meta.query_advice(config.running_sum, Rotation::cur());
+            let one = Expression::Constant(F::ONE);
+
+            // In the case of a running sum decomposition, we recover the word from
+            // the difference of the running sums:
+            //    z_i = 2^{K}⋅z_{i + 1} + a_i
+            // => a_i = z_i - 2^{K}⋅z_{i + 1}
+            let running_sum_lookup = {
+                let running_sum_word = {
+                    let z_next = meta.query_advice(config.running_sum, Rotation::next());
+                    z_cur.clone() - z_next * F::from(1 << K)
+                };
+
+                q_running.clone() * running_sum_word
+            };
+
+            // In the short range check, the word is directly witnessed.
+            let short_lookup = {
+                let short_word = z_cur;
+                let q_short = one - q_running;
+
+                q_short * short_word
+            };
+
+            vec![(
+                q_lookup * (running_sum_lookup + short_lookup),
+                config.table_idx,
+            )]
+        });
+
+        // For short lookups, check that the word has been shifted by the correct number of bits.
+        // https://p.z.cash/halo2-0.1:decompose-short-lookup
+        meta.create_gate("Short lookup bitshift", |meta| {
+            let q_bitshift = meta.query_selector(config.q_bitshift);
+            let word = meta.query_advice(config.running_sum, Rotation::prev());
+            let shifted_word = meta.query_advice(config.running_sum, Rotation::cur());
+            let inv_two_pow_s = meta.query_advice(config.running_sum, Rotation::next());
+
+            let two_pow_k = F::from(1 << K);
+
+            // shifted_word = word * 2^{K-s}
+            //              = word * 2^K * inv_two_pow_s
+            Constraints::with_selector(
+                q_bitshift,
+                Some(word * two_pow_k * inv_two_pow_s - shifted_word),
+            )
+        });
+
+        config
+    }
+
+    #[cfg(test)]
+    // Fill `table_idx` and `table_range_check_tag`.
+    // This is only used in testing for now, since the Sinsemilla chip provides a pre-loaded table
+    // in the Orchard context.
+    fn load(&self, layouter: &mut impl Layouter<F>) -> Result<(), Error> {
+        layouter.assign_table(
+            || "table_idx",
+            |mut table| {
+                // We generate the row values lazily (we only need them during keygen).
+                for index in 0..(1 << K) {
+                    table.assign_cell(
+                        || "table_idx",
+                        self.table_idx,
+                        index,
+                        || Value::known(F::from(index as u64)),
+                    )?;
+                }
+                Ok(())
+            },
+        )
+    }
 
     /// Constrain `x` to be a NUM_BITS word.
     ///
@@ -350,7 +410,7 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
         element: AssignedCell<F, F>,
         num_bits: usize,
     ) -> Result<(), Error> {
-        // Enable lookup for `element`, to constrain it to 10 bits.
+        // Enable lookup for `element`.
         self.q_lookup.enable(region, 0)?;
 
         // Enable lookup for shifted element, to constrain it to 10 bits.
@@ -382,12 +442,23 @@ impl<F: PrimeFieldBits, const K: usize> LookupRangeCheckConfig<F, K> {
     }
 }
 
+/// `PallasLookupRangeCheck` a shorthand for `LookupRangeCheck` specialized with `pallas::Base` and
+/// `sinsemilla::K` and used to improve readability. In addition, it extends
+/// the `LookupRangeCheck` with additional standard traits.
+pub trait PallasLookupRangeCheck:
+    LookupRangeCheck<pallas::Base, { sinsemilla::K }> + Eq + PartialEq + Clone + Copy + Debug
+{
+}
+
+/// `PallasLookupRangeCheckConfig` is a shorthand for `LookupRangeCheckConfig` specialized with
+/// `pallas::Base` and `sinsemilla::K` and used to improve readability```
+pub type PallasLookupRangeCheckConfig = LookupRangeCheckConfig<pallas::Base, { sinsemilla::K }>;
+
+impl PallasLookupRangeCheck for PallasLookupRangeCheckConfig {}
+
 #[cfg(test)]
 mod tests {
-    use super::LookupRangeCheckConfig;
-
     use super::super::lebs2ip;
-    use crate::sinsemilla::primitives::K;
 
     use ff::{Field, PrimeFieldBits};
     use halo2_proofs::{
@@ -397,254 +468,300 @@ mod tests {
     };
     use pasta_curves::pallas;
 
+    use crate::{
+        sinsemilla::primitives::K,
+        tests::test_utils::test_against_stored_circuit,
+        utilities::lookup_range_check::{
+            LookupRangeCheck, PallasLookupRangeCheck, PallasLookupRangeCheckConfig,
+        },
+    };
+
     use std::{convert::TryInto, marker::PhantomData};
 
-    #[test]
-    fn lookup_range_check() {
-        #[derive(Clone, Copy)]
-        struct MyCircuit<F: PrimeFieldBits> {
-            num_words: usize,
-            _marker: PhantomData<F>,
+    #[derive(Clone, Copy)]
+    struct MyLookupCircuit<F: PrimeFieldBits, Lookup: LookupRangeCheck<F, K>> {
+        num_words: usize,
+        _marker: PhantomData<(F, Lookup)>,
+    }
+
+    impl<F: PrimeFieldBits, Lookup: LookupRangeCheck<F, K>> MyLookupCircuit<F, Lookup> {
+        fn new(num_words: usize) -> Self {
+            MyLookupCircuit {
+                num_words,
+                _marker: PhantomData,
+            }
         }
+    }
 
-        impl<F: PrimeFieldBits> Circuit<F> for MyCircuit<F> {
-            type Config = LookupRangeCheckConfig<F, K>;
-            type FloorPlanner = SimpleFloorPlanner;
+    impl<F: PrimeFieldBits, Lookup: LookupRangeCheck<F, K> + std::clone::Clone> Circuit<F>
+        for MyLookupCircuit<F, Lookup>
+    {
+        type Config = Lookup;
+        type FloorPlanner = SimpleFloorPlanner;
 
-            fn without_witnesses(&self) -> Self {
-                *self
-            }
+        fn without_witnesses(&self) -> Self {
+            MyLookupCircuit::new(self.num_words)
+        }
 
-            fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
-                let running_sum = meta.advice_column();
-                let table_idx = meta.lookup_table_column();
-                let constants = meta.fixed_column();
-                meta.enable_constant(constants);
+        fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
+            let running_sum = meta.advice_column();
+            let table_idx = meta.lookup_table_column();
+            let constants = meta.fixed_column();
+            meta.enable_constant(constants);
 
-                LookupRangeCheckConfig::<F, K>::configure(meta, running_sum, table_idx)
-            }
+            Lookup::configure(meta, running_sum, table_idx)
+        }
 
-            fn synthesize(
-                &self,
-                config: Self::Config,
-                mut layouter: impl Layouter<F>,
-            ) -> Result<(), Error> {
-                // Load table_idx
-                config.load(&mut layouter)?;
-
-                // Lookup constraining element to be no longer than num_words * K bits.
-                let elements_and_expected_final_zs = [
-                    (F::from((1 << (self.num_words * K)) - 1), F::ZERO, true), // a word that is within self.num_words * K bits long
-                    (F::from(1 << (self.num_words * K)), F::ONE, false), // a word that is just over self.num_words * K bits long
-                ];
-
-                fn expected_zs<F: PrimeFieldBits, const K: usize>(
-                    element: F,
-                    num_words: usize,
-                ) -> Vec<F> {
-                    let chunks = {
-                        element
-                            .to_le_bits()
-                            .iter()
-                            .by_vals()
-                            .take(num_words * K)
-                            .collect::<Vec<_>>()
-                            .chunks_exact(K)
-                            .map(|chunk| F::from(lebs2ip::<K>(chunk.try_into().unwrap())))
-                            .collect::<Vec<_>>()
-                    };
-                    let expected_zs = {
-                        let inv_two_pow_k = F::from(1 << K).invert().unwrap();
-                        chunks.iter().fold(vec![element], |mut zs, a_i| {
-                            // z_{i + 1} = (z_i - a_i) / 2^{K}
-                            let z = (zs[zs.len() - 1] - a_i) * inv_two_pow_k;
-                            zs.push(z);
-                            zs
-                        })
-                    };
-                    expected_zs
-                }
+        fn synthesize(
+            &self,
+            config: Self::Config,
+            mut layouter: impl Layouter<F>,
+        ) -> Result<(), Error> {
+            // Load table_idx
+            config.load(&mut layouter)?;
+
+            // Lookup constraining element to be no longer than num_words * K bits.
+            let elements_and_expected_final_zs = [
+                (F::from((1 << (self.num_words * K)) - 1), F::ZERO, true), // a word that is within self.num_words * K bits long
+                (F::from(1 << (self.num_words * K)), F::ONE, false), // a word that is just over self.num_words * K bits long
+            ];
+
+            fn expected_zs<F: PrimeFieldBits, const K: usize>(
+                element: F,
+                num_words: usize,
+            ) -> Vec<F> {
+                let chunks = {
+                    element
+                        .to_le_bits()
+                        .iter()
+                        .by_vals()
+                        .take(num_words * K)
+                        .collect::<Vec<_>>()
+                        .chunks_exact(K)
+                        .map(|chunk| F::from(lebs2ip::<K>(chunk.try_into().unwrap())))
+                        .collect::<Vec<_>>()
+                };
+                let expected_zs = {
+                    let inv_two_pow_k = F::from(1 << K).invert().unwrap();
+                    chunks.iter().fold(vec![element], |mut zs, a_i| {
+                        // z_{i + 1} = (z_i - a_i) / 2^{K}
+                        let z = (zs[zs.len() - 1] - a_i) * inv_two_pow_k;
+                        zs.push(z);
+                        zs
+                    })
+                };
+                expected_zs
+            }
 
-                for (element, expected_final_z, strict) in elements_and_expected_final_zs.iter() {
-                    let expected_zs = expected_zs::<F, K>(*element, self.num_words);
+            for (element, expected_final_z, strict) in elements_and_expected_final_zs.iter() {
+                let expected_zs = expected_zs::<F, K>(*element, self.num_words);
 
-                    let zs = config.witness_check(
-                        layouter.namespace(|| format!("Lookup {:?}", self.num_words)),
-                        Value::known(*element),
-                        self.num_words,
-                        *strict,
-                    )?;
+                let zs = config.witness_check(
+                    layouter.namespace(|| format!("Lookup {:?}", self.num_words)),
+                    Value::known(*element),
+                    self.num_words,
+                    *strict,
+                )?;
 
-                    assert_eq!(*expected_zs.last().unwrap(), *expected_final_z);
+                assert_eq!(*expected_zs.last().unwrap(), *expected_final_z);
 
-                    for (expected_z, z) in expected_zs.into_iter().zip(zs.iter()) {
-                        z.value().assert_if_known(|z| &&expected_z == z);
-                    }
+                for (expected_z, z) in expected_zs.into_iter().zip(zs.iter()) {
+                    z.value().assert_if_known(|z| &&expected_z == z);
                 }
-                Ok(())
             }
+            Ok(())
         }
+    }
 
-        {
-            let circuit: MyCircuit<pallas::Base> = MyCircuit {
-                num_words: 6,
-                _marker: PhantomData,
-            };
-
-            let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
-            assert_eq!(prover.verify(), Ok(()));
-        }
+    #[test]
+    fn lookup_range_check() {
+        let circuit = MyLookupCircuit::<pallas::Base, PallasLookupRangeCheckConfig>::new(6);
+        let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
+        assert_eq!(prover.verify(), Ok(()));
     }
 
     #[test]
-    fn short_range_check() {
-        struct MyCircuit<F: PrimeFieldBits> {
-            element: Value<F>,
-            num_bits: usize,
-        }
+    fn test_lookup_range_check_against_stored_circuit() {
+        let circuit = MyLookupCircuit::<pallas::Base, PallasLookupRangeCheckConfig>::new(6);
+        test_against_stored_circuit(circuit, "lookup_range_check", 1888);
+    }
 
-        impl<F: PrimeFieldBits> Circuit<F> for MyCircuit<F> {
-            type Config = LookupRangeCheckConfig<F, K>;
-            type FloorPlanner = SimpleFloorPlanner;
+    #[derive(Clone, Copy)]
+    struct MyShortRangeCheckCircuit<F: PrimeFieldBits, Lookup: LookupRangeCheck<F, K>> {
+        element: Value<F>,
+        num_bits: usize,
+        _lookup_marker: PhantomData<Lookup>,
+    }
 
-            fn without_witnesses(&self) -> Self {
-                MyCircuit {
-                    element: Value::unknown(),
-                    num_bits: self.num_bits,
-                }
+    impl<F: PrimeFieldBits, Lookup: LookupRangeCheck<F, K>> MyShortRangeCheckCircuit<F, Lookup> {
+        fn new(element: Value<F>, num_bits: usize) -> Self {
+            MyShortRangeCheckCircuit {
+                element,
+                num_bits,
+                _lookup_marker: PhantomData,
             }
+        }
+    }
 
-            fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
-                let running_sum = meta.advice_column();
-                let table_idx = meta.lookup_table_column();
-                let constants = meta.fixed_column();
-                meta.enable_constant(constants);
+    impl<F: PrimeFieldBits, Lookup: LookupRangeCheck<F, K> + std::clone::Clone> Circuit<F>
+        for MyShortRangeCheckCircuit<F, Lookup>
+    {
+        type Config = Lookup;
+        type FloorPlanner = SimpleFloorPlanner;
 
-                LookupRangeCheckConfig::<F, K>::configure(meta, running_sum, table_idx)
-            }
+        fn without_witnesses(&self) -> Self {
+            MyShortRangeCheckCircuit::new(Value::unknown(), self.num_bits)
+        }
 
-            fn synthesize(
-                &self,
-                config: Self::Config,
-                mut layouter: impl Layouter<F>,
-            ) -> Result<(), Error> {
-                // Load table_idx
-                config.load(&mut layouter)?;
-
-                // Lookup constraining element to be no longer than num_bits.
-                config.witness_short_check(
-                    layouter.namespace(|| format!("Lookup {:?} bits", self.num_bits)),
-                    self.element,
-                    self.num_bits,
-                )?;
+        fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
+            let running_sum = meta.advice_column();
+            let table_idx = meta.lookup_table_column();
+            let constants = meta.fixed_column();
+            meta.enable_constant(constants);
 
-                Ok(())
-            }
+            Lookup::configure(meta, running_sum, table_idx)
         }
 
-        // Edge case: zero bits
-        {
-            let circuit: MyCircuit<pallas::Base> = MyCircuit {
-                element: Value::known(pallas::Base::ZERO),
-                num_bits: 0,
-            };
-            let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
-            assert_eq!(prover.verify(), Ok(()));
+        fn synthesize(
+            &self,
+            config: Self::Config,
+            mut layouter: impl Layouter<F>,
+        ) -> Result<(), Error> {
+            // Load table_idx
+            config.load(&mut layouter)?;
+
+            // Lookup constraining element to be no longer than num_bits.
+            config.witness_short_check(
+                layouter.namespace(|| format!("Lookup {:?} bits", self.num_bits)),
+                self.element,
+                self.num_bits,
+            )?;
+
+            Ok(())
         }
+    }
 
-        // Edge case: K bits
-        {
-            let circuit: MyCircuit<pallas::Base> = MyCircuit {
-                element: Value::known(pallas::Base::from((1 << K) - 1)),
-                num_bits: K,
-            };
-            let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
-            assert_eq!(prover.verify(), Ok(()));
+    fn test_short_range_check<Lookup: PallasLookupRangeCheck>(
+        element: pallas::Base,
+        num_bits: usize,
+        proof_result: &Result<(), Vec<VerifyFailure>>,
+        circuit_name: &str,
+        expected_proof_size: usize,
+    ) {
+        let circuit =
+            MyShortRangeCheckCircuit::<pallas::Base, Lookup>::new(Value::known(element), num_bits);
+        let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
+        assert_eq!(prover.verify(), *proof_result);
+
+        if proof_result.is_ok() {
+            test_against_stored_circuit(circuit, circuit_name, expected_proof_size);
         }
+    }
 
-        // Element within `num_bits`
-        {
-            let circuit: MyCircuit<pallas::Base> = MyCircuit {
-                element: Value::known(pallas::Base::from((1 << 6) - 1)),
-                num_bits: 6,
-            };
-            let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
-            assert_eq!(prover.verify(), Ok(()));
-        }
+    #[test]
+    fn short_range_check() {
+        let proof_size = 1888;
+
+        // Edge case: zero bits (case 0)
+        let element = pallas::Base::ZERO;
+        let num_bits = 0;
+        test_short_range_check::<PallasLookupRangeCheckConfig>(
+            element,
+            num_bits,
+            &Ok(()),
+            "short_range_check_case0",
+            proof_size,
+        );
+
+        // Edge case: K bits (case 1)
+        let element = pallas::Base::from((1 << K) - 1);
+        let num_bits = K;
+        test_short_range_check::<PallasLookupRangeCheckConfig>(
+            element,
+            num_bits,
+            &Ok(()),
+            "short_range_check_case1",
+            proof_size,
+        );
+
+        // Element within `num_bits` (case 2)
+        let element = pallas::Base::from((1 << 6) - 1);
+        let num_bits = 6;
+        test_short_range_check::<PallasLookupRangeCheckConfig>(
+            element,
+            num_bits,
+            &Ok(()),
+            "short_range_check_case2",
+            proof_size,
+        );
 
         // Element larger than `num_bits` but within K bits
-        {
-            let circuit: MyCircuit<pallas::Base> = MyCircuit {
-                element: Value::known(pallas::Base::from(1 << 6)),
-                num_bits: 6,
-            };
-            let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
-            assert_eq!(
-                prover.verify(),
-                Err(vec![VerifyFailure::Lookup {
-                    lookup_index: 0,
-                    location: FailureLocation::InRegion {
-                        region: (1, "Range check 6 bits").into(),
-                        offset: 1,
-                    },
-                }])
-            );
-        }
+        let element = pallas::Base::from(1 << 6);
+        let num_bits = 6;
+        let error = Err(vec![VerifyFailure::Lookup {
+            lookup_index: 0,
+            location: FailureLocation::InRegion {
+                region: (1, "Range check 6 bits").into(),
+                offset: 1,
+            },
+        }]);
+        test_short_range_check::<PallasLookupRangeCheckConfig>(
+            element,
+            num_bits,
+            &error,
+            "not_saved",
+            proof_size,
+        );
 
         // Element larger than K bits
-        {
-            let circuit: MyCircuit<pallas::Base> = MyCircuit {
-                element: Value::known(pallas::Base::from(1 << K)),
-                num_bits: 6,
-            };
-            let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
-            assert_eq!(
-                prover.verify(),
-                Err(vec![
-                    VerifyFailure::Lookup {
-                        lookup_index: 0,
-                        location: FailureLocation::InRegion {
-                            region: (1, "Range check 6 bits").into(),
-                            offset: 0,
-                        },
-                    },
-                    VerifyFailure::Lookup {
-                        lookup_index: 0,
-                        location: FailureLocation::InRegion {
-                            region: (1, "Range check 6 bits").into(),
-                            offset: 1,
-                        },
-                    },
-                ])
-            );
-        }
-
-        // Element which is not within `num_bits`, but which has a shifted value within
-        // num_bits
-        {
-            let num_bits = 6;
-            let shifted = pallas::Base::from((1 << num_bits) - 1);
-            // Recall that shifted = element * 2^{K-s}
-            //          => element = shifted * 2^{s-K}
-            let element = shifted
-                * pallas::Base::from(1 << (K as u64 - num_bits))
-                    .invert()
-                    .unwrap();
-            let circuit: MyCircuit<pallas::Base> = MyCircuit {
-                element: Value::known(element),
-                num_bits: num_bits as usize,
-            };
-            let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![]).unwrap();
-            assert_eq!(
-                prover.verify(),
-                Err(vec![VerifyFailure::Lookup {
-                    lookup_index: 0,
-                    location: FailureLocation::InRegion {
-                        region: (1, "Range check 6 bits").into(),
-                        offset: 0,
-                    },
-                }])
-            );
-        }
+        let element = pallas::Base::from(1 << K);
+        let num_bits = 6;
+        let error = Err(vec![
+            VerifyFailure::Lookup {
+                lookup_index: 0,
+                location: FailureLocation::InRegion {
+                    region: (1, "Range check 6 bits").into(),
+                    offset: 0,
+                },
+            },
+            VerifyFailure::Lookup {
+                lookup_index: 0,
+                location: FailureLocation::InRegion {
+                    region: (1, "Range check 6 bits").into(),
+                    offset: 1,
+                },
+            },
+        ]);
+        test_short_range_check::<PallasLookupRangeCheckConfig>(
+            element,
+            num_bits,
+            &error,
+            "not_saved",
+            proof_size,
+        );
+
+        // Element which is not within `num_bits`, but which has a shifted value within num_bits
+        let num_bits = 6;
+        let shifted = pallas::Base::from((1 << num_bits) - 1);
+        // Recall that shifted = element * 2^{K-s}
+        //          => element = shifted * 2^{s-K}
+        let element = shifted
+            * pallas::Base::from(1 << (K as u64 - num_bits))
+                .invert()
+                .unwrap();
+        let error = Err(vec![VerifyFailure::Lookup {
+            lookup_index: 0,
+            location: FailureLocation::InRegion {
+                region: (1, "Range check 6 bits").into(),
+                offset: 0,
+            },
+        }]);
+        test_short_range_check::<PallasLookupRangeCheckConfig>(
+            element,
+            num_bits as usize,
+            &error,
+            "not_saved",
+            proof_size,
+        );
     }
 }