diff --git a/barretenberg/cpp/src/barretenberg/proof_system/relations/decomposition_relation.hpp b/barretenberg/cpp/src/barretenberg/proof_system/relations/decomposition_relation.hpp
new file mode 100644
index 000000000000..ff536dd81732
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/proof_system/relations/decomposition_relation.hpp
@@ -0,0 +1,771 @@
+#pragma once
+#include "barretenberg/numeric/uint256/uint256.hpp"
+#include "relation_parameters.hpp"
+#include "relation_types.hpp"
+
+namespace proof_system {
+
+template <typename FF_> class GoblinTranslatorDecompositionRelationImpl {
+  public:
+    using FF = FF_;
+
+    // 1 + polynomial degree of this relation
+    static constexpr size_t RELATION_LENGTH = 3; // degree(lagrange_odd(a - a_0 - a_1*2¹⁴ ... - a_l⋅2¹⁴ˡ )) = 2
+    static constexpr size_t LEN_1 = 3;
+    static constexpr size_t LEN_2 = 3;
+    static constexpr size_t LEN_3 = 3;
+    static constexpr size_t LEN_4 = 3;
+    static constexpr size_t LEN_5 = 3;
+    static constexpr size_t LEN_6 = 3;
+    static constexpr size_t LEN_7 = 3;
+    static constexpr size_t LEN_8 = 3;
+    static constexpr size_t LEN_9 = 3;
+    static constexpr size_t LEN_10 = 3;
+    static constexpr size_t LEN_11 = 3;
+    static constexpr size_t LEN_12 = 3;
+    static constexpr size_t LEN_13 = 3;
+    static constexpr size_t LEN_14 = 3;
+    static constexpr size_t LEN_15 = 3;
+    static constexpr size_t LEN_16 = 3;
+    static constexpr size_t LEN_17 = 3;
+    static constexpr size_t LEN_18 = 3;
+    static constexpr size_t LEN_19 = 3;
+    static constexpr size_t LEN_20 = 3;
+    static constexpr size_t LEN_21 = 3;
+    static constexpr size_t LEN_22 = 3;
+    static constexpr size_t LEN_23 = 3;
+    static constexpr size_t LEN_24 = 3;
+    static constexpr size_t LEN_25 = 3;
+    static constexpr size_t LEN_26 = 3;
+    static constexpr size_t LEN_27 = 3;
+    static constexpr size_t LEN_28 = 3;
+    static constexpr size_t LEN_29 = 3;
+    static constexpr size_t LEN_30 = 3;
+    static constexpr size_t LEN_31 = 3;
+    static constexpr size_t LEN_32 = 3;
+    static constexpr size_t LEN_33 = 3;
+    static constexpr size_t LEN_34 = 3;
+    static constexpr size_t LEN_35 = 3;
+    static constexpr size_t LEN_36 = 3;
+    static constexpr size_t LEN_37 = 3;
+    static constexpr size_t LEN_38 = 3;
+    static constexpr size_t LEN_39 = 3;
+    static constexpr size_t LEN_40 = 3;
+    static constexpr size_t LEN_41 = 3;
+    static constexpr size_t LEN_42 = 3;
+    static constexpr size_t LEN_43 = 3;
+    static constexpr size_t LEN_44 = 3;
+    static constexpr size_t LEN_45 = 3;
+    static constexpr size_t LEN_46 = 3;
+    static constexpr size_t LEN_47 = 3;
+    static constexpr size_t LEN_48 = 3;
+
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1,
+                                                                LEN_2,
+                                                                LEN_3,
+                                                                LEN_4,
+                                                                LEN_5,
+                                                                LEN_6,
+                                                                LEN_7,
+                                                                LEN_8,
+                                                                LEN_9,
+                                                                LEN_10,
+                                                                LEN_11,
+                                                                LEN_12,
+                                                                LEN_13,
+                                                                LEN_14,
+                                                                LEN_15,
+                                                                LEN_16,
+                                                                LEN_17,
+                                                                LEN_18,
+                                                                LEN_19,
+                                                                LEN_20,
+                                                                LEN_21,
+                                                                LEN_22,
+                                                                LEN_23,
+                                                                LEN_24,
+                                                                LEN_25,
+                                                                LEN_26,
+                                                                LEN_27,
+                                                                LEN_28,
+                                                                LEN_29,
+                                                                LEN_30,
+                                                                LEN_31,
+                                                                LEN_32,
+                                                                LEN_33,
+                                                                LEN_34,
+                                                                LEN_35,
+                                                                LEN_36,
+                                                                LEN_37,
+                                                                LEN_38,
+                                                                LEN_39,
+                                                                LEN_40,
+                                                                LEN_41,
+                                                                LEN_42,
+                                                                LEN_43,
+                                                                LEN_44,
+                                                                LEN_45,
+                                                                LEN_46,
+                                                                LEN_47,
+                                                                LEN_48>;
+
+    /**
+     * @brief Expression for decomposition of various values into smaller limbs.
+     * @details This relation enforces three types of subrelations:
+     * 1) A subrelation decomposing a value from the transcript (for example, z1) into 68-bit limbs. These relations
+     * will have the structure `lagrange_odd⋅(a - a_low - a_high⋅2⁶⁸)`
+     * 2) A subrelation decomposing a value  of one of the limbs used in bigfield computation (for example, the lower
+     * wide relation limb) into 14-bit limbs. These relations will have the structure `lagrange_odd⋅(a - a_0 - a_1⋅2¹⁴ -
+     * ....)` 3) A subrelation making a microlimb range constraint more constraining. For example, we want to constrain
+     * some values to 12 bits instead of 14. So we add a constraint `lagrange_odd⋅(a_highest⋅4 - a_tail)`. In a separate
+     * relation both a_highest and a_tail are constrained to be 14 bits, but this relation changes the constraint on
+     * a_highest to be 12 bits.
+     *
+     * @param evals transformed to `evals + C(extended_edges(X)...)*scaling_factor`
+     * @param extended_edges an std::array containing the fully extended Univariate edges.
+     * @param parameters contains beta, gamma, and public_input_delta, ....
+     * @param scaling_factor optional term to scale the evaluation before adding to evals.
+     */
+    template <typename AccumulatorTypes>
+    void static accumulate(typename AccumulatorTypes::Accumulators& accumulators,
+                           const auto& extended_edges,
+                           const RelationParameters<FF>&,
+                           const FF& scaling_factor)
+    {
+        static constexpr size_t NUM_LIMB_BITS = 68; // Number of bits in a standard limb used for bigfield operations
+        static constexpr size_t NUM_MICRO_LIMB_BITS =
+            14; // Number of bits in a standard limb used for bigfield operations
+
+        // Value to multiply an element by to perform an appropriate shift
+        static constexpr auto LIMB_SHIFT = FF(uint256_t(1) << NUM_LIMB_BITS);
+
+        // Values to multiply an element by to perform an appropriate shift
+        static constexpr auto MICRO_LIMB_SHIFT = FF(uint256_t(1) << NUM_MICRO_LIMB_BITS);
+        static constexpr auto MICRO_LIMB_SHIFTx2 = MICRO_LIMB_SHIFT * MICRO_LIMB_SHIFT;
+        static constexpr auto MICRO_LIMB_SHIFTx3 = MICRO_LIMB_SHIFTx2 * MICRO_LIMB_SHIFT;
+        static constexpr auto MICRO_LIMB_SHIFTx4 = MICRO_LIMB_SHIFTx3 * MICRO_LIMB_SHIFT;
+        static constexpr auto MICRO_LIMB_SHIFTx5 = MICRO_LIMB_SHIFTx4 * MICRO_LIMB_SHIFT;
+
+        // Shifts used to constrain ranges further
+        static constexpr auto SHIFT_12_TO_14 =
+            FF(4); // Shift used to range constrain the last microlimb of 68-bit limbs (standard limbs)
+        static constexpr auto SHIFT_10_TO_14 =
+            FF(16); // Shift used to range constrain the last microlimb of 52-bit limb (top quotient limb)
+        static constexpr auto SHIFT_8_TO_14 = FF(64); // Shift used to range constrain the last microlimb of 50-bit
+                                                      // limbs (top limb of standard 254-bit value)
+        static constexpr auto SHIFT_4_TO_14 =
+            FF(1024); // Shift used to range constrain the last mircrolimb of 60-bit limbs from z scalars
+
+        using View = typename std::tuple_element<0, typename AccumulatorTypes::AccumulatorViews>::type;
+        auto p_x_low_limbs = View(extended_edges.p_x_low_limbs);
+        auto p_x_low_limbs_range_constraint_0 = View(extended_edges.p_x_low_limbs_range_constraint_0);
+        auto p_x_low_limbs_range_constraint_1 = View(extended_edges.p_x_low_limbs_range_constraint_1);
+        auto p_x_low_limbs_range_constraint_2 = View(extended_edges.p_x_low_limbs_range_constraint_2);
+        auto p_x_low_limbs_range_constraint_3 = View(extended_edges.p_x_low_limbs_range_constraint_3);
+        auto p_x_low_limbs_range_constraint_4 = View(extended_edges.p_x_low_limbs_range_constraint_4);
+        auto p_x_low_limbs_shift = View(extended_edges.p_x_low_limbs_shift);
+        auto p_x_low_limbs_range_constraint_0_shift = View(extended_edges.p_x_low_limbs_range_constraint_0_shift);
+        auto p_x_low_limbs_range_constraint_1_shift = View(extended_edges.p_x_low_limbs_range_constraint_1_shift);
+        auto p_x_low_limbs_range_constraint_2_shift = View(extended_edges.p_x_low_limbs_range_constraint_2_shift);
+        auto p_x_low_limbs_range_constraint_3_shift = View(extended_edges.p_x_low_limbs_range_constraint_3_shift);
+        auto p_x_low_limbs_range_constraint_4_shift = View(extended_edges.p_x_low_limbs_range_constraint_4_shift);
+        auto p_x_high_limbs = View(extended_edges.p_x_high_limbs);
+        auto p_x_high_limbs_range_constraint_0 = View(extended_edges.p_x_high_limbs_range_constraint_0);
+        auto p_x_high_limbs_range_constraint_1 = View(extended_edges.p_x_high_limbs_range_constraint_1);
+        auto p_x_high_limbs_range_constraint_2 = View(extended_edges.p_x_high_limbs_range_constraint_2);
+        auto p_x_high_limbs_range_constraint_3 = View(extended_edges.p_x_high_limbs_range_constraint_3);
+        auto p_x_high_limbs_range_constraint_4 = View(extended_edges.p_x_high_limbs_range_constraint_4);
+        auto p_x_high_limbs_shift = View(extended_edges.p_x_high_limbs_shift);
+        auto p_x_high_limbs_range_constraint_0_shift = View(extended_edges.p_x_high_limbs_range_constraint_0_shift);
+        auto p_x_high_limbs_range_constraint_1_shift = View(extended_edges.p_x_high_limbs_range_constraint_1_shift);
+        auto p_x_high_limbs_range_constraint_2_shift = View(extended_edges.p_x_high_limbs_range_constraint_2_shift);
+        auto p_x_high_limbs_range_constraint_3_shift = View(extended_edges.p_x_high_limbs_range_constraint_3_shift);
+        auto p_y_low_limbs = View(extended_edges.p_y_low_limbs);
+        auto p_y_low_limbs_range_constraint_0 = View(extended_edges.p_y_low_limbs_range_constraint_0);
+        auto p_y_low_limbs_range_constraint_1 = View(extended_edges.p_y_low_limbs_range_constraint_1);
+        auto p_y_low_limbs_range_constraint_2 = View(extended_edges.p_y_low_limbs_range_constraint_2);
+        auto p_y_low_limbs_range_constraint_3 = View(extended_edges.p_y_low_limbs_range_constraint_3);
+        auto p_y_low_limbs_range_constraint_4 = View(extended_edges.p_y_low_limbs_range_constraint_4);
+        auto p_y_low_limbs_shift = View(extended_edges.p_y_low_limbs_shift);
+        auto p_y_low_limbs_range_constraint_0_shift = View(extended_edges.p_y_low_limbs_range_constraint_0_shift);
+        auto p_y_low_limbs_range_constraint_1_shift = View(extended_edges.p_y_low_limbs_range_constraint_1_shift);
+        auto p_y_low_limbs_range_constraint_2_shift = View(extended_edges.p_y_low_limbs_range_constraint_2_shift);
+        auto p_y_low_limbs_range_constraint_3_shift = View(extended_edges.p_y_low_limbs_range_constraint_3_shift);
+        auto p_y_low_limbs_range_constraint_4_shift = View(extended_edges.p_y_low_limbs_range_constraint_4_shift);
+        auto p_y_high_limbs = View(extended_edges.p_y_high_limbs);
+        auto p_y_high_limbs_range_constraint_0 = View(extended_edges.p_y_high_limbs_range_constraint_0);
+        auto p_y_high_limbs_range_constraint_1 = View(extended_edges.p_y_high_limbs_range_constraint_1);
+        auto p_y_high_limbs_range_constraint_2 = View(extended_edges.p_y_high_limbs_range_constraint_2);
+        auto p_y_high_limbs_range_constraint_3 = View(extended_edges.p_y_high_limbs_range_constraint_3);
+        auto p_y_high_limbs_range_constraint_4 = View(extended_edges.p_y_high_limbs_range_constraint_4);
+        auto p_y_high_limbs_shift = View(extended_edges.p_y_high_limbs_shift);
+        auto p_y_high_limbs_range_constraint_0_shift = View(extended_edges.p_y_high_limbs_range_constraint_0_shift);
+        auto p_y_high_limbs_range_constraint_1_shift = View(extended_edges.p_y_high_limbs_range_constraint_1_shift);
+        auto p_y_high_limbs_range_constraint_2_shift = View(extended_edges.p_y_high_limbs_range_constraint_2_shift);
+        auto p_y_high_limbs_range_constraint_3_shift = View(extended_edges.p_y_high_limbs_range_constraint_3_shift);
+        auto z_low_limbs = View(extended_edges.z_low_limbs);
+        auto z_low_limbs_range_constraint_0 = View(extended_edges.z_low_limbs_range_constraint_0);
+        auto z_low_limbs_range_constraint_1 = View(extended_edges.z_low_limbs_range_constraint_1);
+        auto z_low_limbs_range_constraint_2 = View(extended_edges.z_low_limbs_range_constraint_2);
+        auto z_low_limbs_range_constraint_3 = View(extended_edges.z_low_limbs_range_constraint_3);
+        auto z_low_limbs_range_constraint_4 = View(extended_edges.z_low_limbs_range_constraint_4);
+        auto z_low_limbs_shift = View(extended_edges.z_low_limbs_shift);
+        auto z_low_limbs_range_constraint_0_shift = View(extended_edges.z_low_limbs_range_constraint_0_shift);
+        auto z_low_limbs_range_constraint_1_shift = View(extended_edges.z_low_limbs_range_constraint_1_shift);
+        auto z_low_limbs_range_constraint_2_shift = View(extended_edges.z_low_limbs_range_constraint_2_shift);
+        auto z_low_limbs_range_constraint_3_shift = View(extended_edges.z_low_limbs_range_constraint_3_shift);
+        auto z_low_limbs_range_constraint_4_shift = View(extended_edges.z_low_limbs_range_constraint_4_shift);
+        auto z_high_limbs = View(extended_edges.z_high_limbs);
+        auto z_high_limbs_range_constraint_0 = View(extended_edges.z_high_limbs_range_constraint_0);
+        auto z_high_limbs_range_constraint_1 = View(extended_edges.z_high_limbs_range_constraint_1);
+        auto z_high_limbs_range_constraint_2 = View(extended_edges.z_high_limbs_range_constraint_2);
+        auto z_high_limbs_range_constraint_3 = View(extended_edges.z_high_limbs_range_constraint_3);
+        auto z_high_limbs_range_constraint_4 = View(extended_edges.z_high_limbs_range_constraint_4);
+        auto z_high_limbs_shift = View(extended_edges.z_high_limbs_shift);
+        auto z_high_limbs_range_constraint_0_shift = View(extended_edges.z_high_limbs_range_constraint_0_shift);
+        auto z_high_limbs_range_constraint_1_shift = View(extended_edges.z_high_limbs_range_constraint_1_shift);
+        auto z_high_limbs_range_constraint_2_shift = View(extended_edges.z_high_limbs_range_constraint_2_shift);
+        auto z_high_limbs_range_constraint_3_shift = View(extended_edges.z_high_limbs_range_constraint_3_shift);
+        auto z_high_limbs_range_constraint_4_shift = View(extended_edges.z_high_limbs_range_constraint_4_shift);
+        auto accumulators_binary_limbs_0 = View(extended_edges.accumulators_binary_limbs_0);
+        auto accumulators_binary_limbs_1 = View(extended_edges.accumulators_binary_limbs_1);
+        auto accumulators_binary_limbs_2 = View(extended_edges.accumulators_binary_limbs_2);
+        auto accumulators_binary_limbs_3 = View(extended_edges.accumulators_binary_limbs_3);
+        auto accumulator_low_limbs_range_constraint_0 = View(extended_edges.accumulator_low_limbs_range_constraint_0);
+        auto accumulator_low_limbs_range_constraint_1 = View(extended_edges.accumulator_low_limbs_range_constraint_1);
+        auto accumulator_low_limbs_range_constraint_2 = View(extended_edges.accumulator_low_limbs_range_constraint_2);
+        auto accumulator_low_limbs_range_constraint_3 = View(extended_edges.accumulator_low_limbs_range_constraint_3);
+        auto accumulator_low_limbs_range_constraint_4 = View(extended_edges.accumulator_low_limbs_range_constraint_4);
+        auto accumulator_low_limbs_range_constraint_0_shift =
+            View(extended_edges.accumulator_low_limbs_range_constraint_0_shift);
+        auto accumulator_low_limbs_range_constraint_1_shift =
+            View(extended_edges.accumulator_low_limbs_range_constraint_1_shift);
+        auto accumulator_low_limbs_range_constraint_2_shift =
+            View(extended_edges.accumulator_low_limbs_range_constraint_2_shift);
+        auto accumulator_low_limbs_range_constraint_3_shift =
+            View(extended_edges.accumulator_low_limbs_range_constraint_3_shift);
+        auto accumulator_low_limbs_range_constraint_4_shift =
+            View(extended_edges.accumulator_low_limbs_range_constraint_4_shift);
+        auto accumulator_high_limbs_range_constraint_0 = View(extended_edges.accumulator_high_limbs_range_constraint_0);
+        auto accumulator_high_limbs_range_constraint_1 = View(extended_edges.accumulator_high_limbs_range_constraint_1);
+        auto accumulator_high_limbs_range_constraint_2 = View(extended_edges.accumulator_high_limbs_range_constraint_2);
+        auto accumulator_high_limbs_range_constraint_3 = View(extended_edges.accumulator_high_limbs_range_constraint_3);
+        auto accumulator_high_limbs_range_constraint_4 = View(extended_edges.accumulator_high_limbs_range_constraint_4);
+        auto accumulator_high_limbs_range_constraint_0_shift =
+            View(extended_edges.accumulator_high_limbs_range_constraint_0_shift);
+        auto accumulator_high_limbs_range_constraint_1_shift =
+            View(extended_edges.accumulator_high_limbs_range_constraint_1_shift);
+        auto accumulator_high_limbs_range_constraint_2_shift =
+            View(extended_edges.accumulator_high_limbs_range_constraint_2_shift);
+        auto accumulator_high_limbs_range_constraint_3_shift =
+            View(extended_edges.accumulator_high_limbs_range_constraint_3_shift);
+        auto quotient_low_binary_limbs = View(extended_edges.quotient_low_binary_limbs);
+        auto quotient_low_limbs_range_constraint_0 = View(extended_edges.quotient_low_limbs_range_constraint_0);
+        auto quotient_low_limbs_range_constraint_1 = View(extended_edges.quotient_low_limbs_range_constraint_1);
+        auto quotient_low_limbs_range_constraint_2 = View(extended_edges.quotient_low_limbs_range_constraint_2);
+        auto quotient_low_limbs_range_constraint_3 = View(extended_edges.quotient_low_limbs_range_constraint_3);
+        auto quotient_low_limbs_range_constraint_4 = View(extended_edges.quotient_low_limbs_range_constraint_4);
+        auto quotient_low_binary_limbs_shift = View(extended_edges.quotient_low_binary_limbs_shift);
+        auto quotient_low_limbs_range_constraint_0_shift =
+            View(extended_edges.quotient_low_limbs_range_constraint_0_shift);
+        auto quotient_low_limbs_range_constraint_1_shift =
+            View(extended_edges.quotient_low_limbs_range_constraint_1_shift);
+        auto quotient_low_limbs_range_constraint_2_shift =
+            View(extended_edges.quotient_low_limbs_range_constraint_2_shift);
+        auto quotient_low_limbs_range_constraint_3_shift =
+            View(extended_edges.quotient_low_limbs_range_constraint_3_shift);
+        auto quotient_low_limbs_range_constraint_4_shift =
+            View(extended_edges.quotient_low_limbs_range_constraint_4_shift);
+        auto quotient_high_binary_limbs = View(extended_edges.quotient_high_binary_limbs);
+        auto quotient_high_limbs_range_constraint_0 = View(extended_edges.quotient_high_limbs_range_constraint_0);
+        auto quotient_high_limbs_range_constraint_1 = View(extended_edges.quotient_high_limbs_range_constraint_1);
+        auto quotient_high_limbs_range_constraint_2 = View(extended_edges.quotient_high_limbs_range_constraint_2);
+        auto quotient_high_limbs_range_constraint_3 = View(extended_edges.quotient_high_limbs_range_constraint_3);
+        auto quotient_high_limbs_range_constraint_4 = View(extended_edges.quotient_high_limbs_range_constraint_4);
+        auto quotient_high_binary_limbs_shift = View(extended_edges.quotient_high_binary_limbs_shift);
+        auto quotient_high_limbs_range_constraint_0_shift =
+            View(extended_edges.quotient_high_limbs_range_constraint_0_shift);
+        auto quotient_high_limbs_range_constraint_1_shift =
+            View(extended_edges.quotient_high_limbs_range_constraint_1_shift);
+        auto quotient_high_limbs_range_constraint_2_shift =
+            View(extended_edges.quotient_high_limbs_range_constraint_2_shift);
+        auto quotient_high_limbs_range_constraint_3_shift =
+            View(extended_edges.quotient_high_limbs_range_constraint_3_shift);
+        auto relation_wide_limbs = View(extended_edges.relation_wide_limbs);
+        auto relation_wide_limbs_range_constraint_0 = View(extended_edges.relation_wide_limbs_range_constraint_0);
+        auto relation_wide_limbs_range_constraint_1 = View(extended_edges.relation_wide_limbs_range_constraint_1);
+        auto relation_wide_limbs_range_constraint_2 = View(extended_edges.relation_wide_limbs_range_constraint_2);
+        auto relation_wide_limbs_range_constraint_3 = View(extended_edges.relation_wide_limbs_range_constraint_3);
+        auto p_x_high_limbs_range_constraint_tail_shift =
+            View(extended_edges.p_x_high_limbs_range_constraint_tail_shift);
+        auto accumulator_high_limbs_range_constraint_tail_shift =
+            View(extended_edges.accumulator_high_limbs_range_constraint_tail_shift);
+        auto relation_wide_limbs_shift = View(extended_edges.relation_wide_limbs_shift);
+        auto relation_wide_limbs_range_constraint_0_shift =
+            View(extended_edges.relation_wide_limbs_range_constraint_0_shift);
+        auto relation_wide_limbs_range_constraint_1_shift =
+            View(extended_edges.relation_wide_limbs_range_constraint_1_shift);
+        auto relation_wide_limbs_range_constraint_2_shift =
+            View(extended_edges.relation_wide_limbs_range_constraint_2_shift);
+        auto relation_wide_limbs_range_constraint_3_shift =
+            View(extended_edges.relation_wide_limbs_range_constraint_3_shift);
+        auto p_y_high_limbs_range_constraint_tail_shift =
+            View(extended_edges.p_y_high_limbs_range_constraint_tail_shift);
+        auto quotient_high_limbs_range_constraint_tail_shift =
+            View(extended_edges.quotient_high_limbs_range_constraint_tail_shift);
+        auto p_x_low_limbs_range_constraint_tail = View(extended_edges.p_x_low_limbs_range_constraint_tail);
+        auto p_x_low_limbs_range_constraint_tail_shift = View(extended_edges.p_x_low_limbs_range_constraint_tail_shift);
+        auto p_x_high_limbs_range_constraint_tail = View(extended_edges.p_x_high_limbs_range_constraint_tail);
+        auto p_x_high_limbs_range_constraint_4_shift = View(extended_edges.p_x_high_limbs_range_constraint_4_shift);
+        auto p_y_low_limbs_range_constraint_tail = View(extended_edges.p_y_low_limbs_range_constraint_tail);
+        auto p_y_low_limbs_range_constraint_tail_shift = View(extended_edges.p_y_low_limbs_range_constraint_tail_shift);
+        auto p_y_high_limbs_range_constraint_tail = View(extended_edges.p_y_high_limbs_range_constraint_tail);
+        auto p_y_high_limbs_range_constraint_4_shift = View(extended_edges.p_y_high_limbs_range_constraint_4_shift);
+        auto z_low_limbs_range_constraint_tail = View(extended_edges.z_low_limbs_range_constraint_tail);
+        auto z_low_limbs_range_constraint_tail_shift = View(extended_edges.z_low_limbs_range_constraint_tail_shift);
+        auto z_high_limbs_range_constraint_tail = View(extended_edges.z_high_limbs_range_constraint_tail);
+        auto z_high_limbs_range_constraint_tail_shift = View(extended_edges.z_high_limbs_range_constraint_tail_shift);
+        auto accumulator_low_limbs_range_constraint_tail =
+            View(extended_edges.accumulator_low_limbs_range_constraint_tail);
+        auto accumulator_low_limbs_range_constraint_tail_shift =
+            View(extended_edges.accumulator_low_limbs_range_constraint_tail_shift);
+        auto accumulator_high_limbs_range_constraint_tail =
+            View(extended_edges.accumulator_high_limbs_range_constraint_tail);
+        auto accumulator_high_limbs_range_constraint_4_shift =
+            View(extended_edges.accumulator_high_limbs_range_constraint_4_shift);
+        auto quotient_low_limbs_range_constraint_tail = View(extended_edges.quotient_low_limbs_range_constraint_tail);
+        auto quotient_low_limbs_range_constraint_tail_shift =
+            View(extended_edges.quotient_low_limbs_range_constraint_tail_shift);
+        auto quotient_high_limbs_range_constraint_tail = View(extended_edges.quotient_high_limbs_range_constraint_tail);
+        auto quotient_high_limbs_range_constraint_4_shift =
+            View(extended_edges.quotient_high_limbs_range_constraint_4_shift);
+        auto x_lo_y_hi = View(extended_edges.x_lo_y_hi);
+        auto x_hi_z_1 = View(extended_edges.x_hi_z_1);
+        auto y_lo_z_2 = View(extended_edges.y_lo_z_2);
+        auto x_lo_y_hi_shift = View(extended_edges.x_lo_y_hi_shift);
+        auto x_hi_z_1_shift = View(extended_edges.x_hi_z_1_shift);
+        auto y_lo_z_2_shift = View(extended_edges.y_lo_z_2_shift);
+        auto lagrange_odd = View(extended_edges.lagrange_odd);
+
+        // Contributions that decompose 50, 52, 68 or 84 bit limbs used for computation into range-constrained chunks
+        // Contribution 1 , P_x lowest limb decomposition
+        auto tmp_1 = ((p_x_low_limbs_range_constraint_0 + p_x_low_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+                       p_x_low_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+                       p_x_low_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+                       p_x_low_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+                      p_x_low_limbs);
+        tmp_1 *= lagrange_odd;
+        tmp_1 *= scaling_factor;
+        std::get<0>(accumulators) += tmp_1;
+
+        // Contribution 2 , P_x second lowest limb decomposition
+        auto tmp_2 =
+            ((p_x_low_limbs_range_constraint_0_shift + p_x_low_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+              p_x_low_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+              p_x_low_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3 +
+              p_x_low_limbs_range_constraint_4_shift * MICRO_LIMB_SHIFTx4) -
+             p_x_low_limbs_shift);
+        tmp_2 *= lagrange_odd;
+        tmp_2 *= scaling_factor;
+        std::get<1>(accumulators) += tmp_2;
+
+        // Contribution 3 , P_x third limb decomposition
+        auto tmp_3 = ((p_x_high_limbs_range_constraint_0 + p_x_high_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+                       p_x_high_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+                       p_x_high_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+                       p_x_high_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+                      p_x_high_limbs);
+        tmp_3 *= lagrange_odd;
+        tmp_3 *= scaling_factor;
+        std::get<2>(accumulators) += tmp_3;
+
+        // Contribution 4 , P_x highest limb decomposition
+        auto tmp_4 =
+            ((p_x_high_limbs_range_constraint_0_shift + p_x_high_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+              p_x_high_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+              p_x_high_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3) -
+             p_x_high_limbs_shift);
+        tmp_4 *= lagrange_odd;
+        tmp_4 *= scaling_factor;
+        std::get<3>(accumulators) += tmp_4;
+
+        // Contribution 5 , P_y lowest limb decomposition
+        auto tmp_5 = ((p_y_low_limbs_range_constraint_0 + p_y_low_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+                       p_y_low_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+                       p_y_low_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+                       p_y_low_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+                      p_y_low_limbs);
+        tmp_5 *= lagrange_odd;
+        tmp_5 *= scaling_factor;
+        std::get<4>(accumulators) += tmp_5;
+
+        // Contribution 6 , P_y second lowest limb decomposition
+        auto tmp_6 =
+            ((p_y_low_limbs_range_constraint_0_shift + p_y_low_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+              p_y_low_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+              p_y_low_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3 +
+              p_y_low_limbs_range_constraint_4_shift * MICRO_LIMB_SHIFTx4) -
+             p_y_low_limbs_shift);
+        tmp_6 *= lagrange_odd;
+        tmp_6 *= scaling_factor;
+        std::get<5>(accumulators) += tmp_6;
+
+        // Contribution 7 , P_y third limb decomposition
+        auto tmp_7 = ((p_y_high_limbs_range_constraint_0 + p_y_high_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+                       p_y_high_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+                       p_y_high_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+                       p_y_high_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+                      p_y_high_limbs);
+        tmp_7 *= lagrange_odd;
+        tmp_7 *= scaling_factor;
+        std::get<6>(accumulators) += tmp_7;
+
+        // Contribution 8 , P_y highest limb decomposition
+        auto tmp_8 =
+            ((p_y_high_limbs_range_constraint_0_shift + p_y_high_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+              p_y_high_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+              p_y_high_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3) -
+             p_y_high_limbs_shift);
+        tmp_8 *= lagrange_odd;
+        tmp_8 *= scaling_factor;
+        std::get<7>(accumulators) += tmp_8;
+
+        // Contribution 9 , z_1 low limb decomposition
+        auto tmp_9 = ((z_low_limbs_range_constraint_0 + z_low_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+                       z_low_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+                       z_low_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+                       z_low_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+                      z_low_limbs);
+        tmp_9 *= lagrange_odd;
+        tmp_9 *= scaling_factor;
+        std::get<8>(accumulators) += tmp_9;
+
+        // Contribution 10 , z_2 low limb decomposition
+        auto tmp_10 = ((z_low_limbs_range_constraint_0_shift + z_low_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+                        z_low_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+                        z_low_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3 +
+                        z_low_limbs_range_constraint_4_shift * MICRO_LIMB_SHIFTx4) -
+                       z_low_limbs_shift);
+        tmp_10 *= lagrange_odd;
+        tmp_10 *= scaling_factor;
+        std::get<9>(accumulators) += tmp_10;
+
+        // Contribution 11 , z_1 high limb decomposition
+        auto tmp_11 = ((z_high_limbs_range_constraint_0 + z_high_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+                        z_high_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+                        z_high_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+                        z_high_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+                       z_high_limbs);
+        tmp_11 *= lagrange_odd;
+        tmp_11 *= scaling_factor;
+        std::get<10>(accumulators) += tmp_11;
+
+        // Contribution 12 , z_2 high limb decomposition
+        auto tmp_12 =
+            ((z_high_limbs_range_constraint_0_shift + z_high_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+              z_high_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+              z_high_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3 +
+              z_high_limbs_range_constraint_4_shift * MICRO_LIMB_SHIFTx4) -
+             z_high_limbs_shift);
+        tmp_12 *= lagrange_odd;
+        tmp_12 *= scaling_factor;
+        std::get<11>(accumulators) += tmp_12;
+
+        // Contribution 13 , accumulator lowest limb decomposition
+        auto tmp_13 =
+            ((accumulator_low_limbs_range_constraint_0 + accumulator_low_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+              accumulator_low_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+              accumulator_low_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+              accumulator_low_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+             accumulators_binary_limbs_0);
+        tmp_13 *= lagrange_odd;
+        tmp_13 *= scaling_factor;
+        std::get<12>(accumulators) += tmp_13;
+        // Contribution 14 , accumulator second limb decomposition
+        auto tmp_14 = ((accumulator_low_limbs_range_constraint_0_shift +
+                        accumulator_low_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+                        accumulator_low_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+                        accumulator_low_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3 +
+                        accumulator_low_limbs_range_constraint_4_shift * MICRO_LIMB_SHIFTx4) -
+                       accumulators_binary_limbs_1);
+        tmp_14 *= lagrange_odd;
+        tmp_14 *= scaling_factor;
+        std::get<13>(accumulators) += tmp_14;
+
+        // Contribution 15 , accumulator second highest limb decomposition
+        auto tmp_15 =
+            ((accumulator_high_limbs_range_constraint_0 + accumulator_high_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+              accumulator_high_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+              accumulator_high_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+              accumulator_high_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+             accumulators_binary_limbs_2);
+        tmp_15 *= lagrange_odd;
+        tmp_15 *= scaling_factor;
+        std::get<14>(accumulators) += tmp_15;
+        // Contribution 16 , accumulator highest limb decomposition
+        auto tmp_16 = ((accumulator_high_limbs_range_constraint_0_shift +
+                        accumulator_high_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+                        accumulator_high_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+                        accumulator_high_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3) -
+                       accumulators_binary_limbs_3);
+        tmp_16 *= lagrange_odd;
+        tmp_16 *= scaling_factor;
+        std::get<15>(accumulators) += tmp_16;
+
+        // Contribution 15 , quotient lowest limb decomposition
+        auto tmp_17 =
+            ((quotient_low_limbs_range_constraint_0 + quotient_low_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+              quotient_low_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+              quotient_low_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+              quotient_low_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+             quotient_low_binary_limbs);
+        tmp_17 *= lagrange_odd;
+        tmp_17 *= scaling_factor;
+        std::get<16>(accumulators) += tmp_17;
+        // Contribution 16 , quotient second lowest limb decomposition
+        auto tmp_18 = ((quotient_low_limbs_range_constraint_0_shift +
+                        quotient_low_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+                        quotient_low_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+                        quotient_low_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3 +
+                        quotient_low_limbs_range_constraint_4_shift * MICRO_LIMB_SHIFTx4) -
+                       quotient_low_binary_limbs_shift);
+        tmp_18 *= lagrange_odd;
+        tmp_18 *= scaling_factor;
+        std::get<17>(accumulators) += tmp_18;
+
+        // Contribution 19 , quotient second highest limb decomposition
+        auto tmp_19 =
+            ((quotient_high_limbs_range_constraint_0 + quotient_high_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+              quotient_high_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+              quotient_high_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+              quotient_high_limbs_range_constraint_4 * MICRO_LIMB_SHIFTx4) -
+             quotient_high_binary_limbs);
+        tmp_19 *= lagrange_odd;
+        tmp_19 *= scaling_factor;
+        std::get<18>(accumulators) += tmp_19;
+        // Contribution 20 , quotient highest limb decomposition
+        auto tmp_20 = ((quotient_high_limbs_range_constraint_0_shift +
+                        quotient_high_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+                        quotient_high_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+                        quotient_high_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3) -
+                       quotient_high_binary_limbs_shift);
+        tmp_20 *= lagrange_odd;
+        tmp_20 *= scaling_factor;
+        std::get<19>(accumulators) += tmp_20;
+
+        // Contribution 21 , decomposition of the low wide relation limb used for the bigfield relation.
+        // N.B. top microlimbs of relation wide limbs are stored in microlimbs for range constraints of P_x, P_y,
+        // accumulator and quotient. This is to save space and because these microlimbs are not used by their namesakes,
+        // since top limbs in 254/6-bit values use one less microlimb for the top 50/52-bit limb
+        auto tmp_21 =
+            ((relation_wide_limbs_range_constraint_0 + relation_wide_limbs_range_constraint_1 * MICRO_LIMB_SHIFT +
+              relation_wide_limbs_range_constraint_2 * MICRO_LIMB_SHIFTx2 +
+              relation_wide_limbs_range_constraint_3 * MICRO_LIMB_SHIFTx3 +
+              p_x_high_limbs_range_constraint_tail_shift * MICRO_LIMB_SHIFTx4 +
+              accumulator_high_limbs_range_constraint_tail_shift * MICRO_LIMB_SHIFTx5) -
+             relation_wide_limbs);
+        tmp_21 *= lagrange_odd;
+        tmp_21 *= scaling_factor;
+        std::get<20>(accumulators) += tmp_21;
+
+        // Contribution 22 , decomposition of high relation limb
+        auto tmp_22 = ((relation_wide_limbs_range_constraint_0_shift +
+                        relation_wide_limbs_range_constraint_1_shift * MICRO_LIMB_SHIFT +
+                        relation_wide_limbs_range_constraint_2_shift * MICRO_LIMB_SHIFTx2 +
+                        relation_wide_limbs_range_constraint_3_shift * MICRO_LIMB_SHIFTx3 +
+                        p_y_high_limbs_range_constraint_tail_shift * MICRO_LIMB_SHIFTx4 +
+                        quotient_high_limbs_range_constraint_tail_shift * MICRO_LIMB_SHIFTx5) -
+                       relation_wide_limbs_shift);
+        tmp_22 *= lagrange_odd;
+        tmp_22 *= scaling_factor;
+        std::get<21>(accumulators) += tmp_22;
+
+        // Contributions enfocing a reduced range constraint on high limbs (these relation force the last microlimb in
+        // each limb to be more severely range constrained)
+
+        // Contribution 23, range constrain the highest microlimb of lowest P.x limb to be 12 bits (68 % 14 = 12)
+        auto tmp_23 = p_x_low_limbs_range_constraint_4 * SHIFT_12_TO_14 - p_x_low_limbs_range_constraint_tail;
+        tmp_23 *= lagrange_odd;
+        tmp_23 *= scaling_factor;
+        std::get<22>(accumulators) += tmp_23;
+
+        // Contribution 24, range constrain the highest microlimb of second lowest P.x limb to be 12 bits
+        auto tmp_24 =
+            p_x_low_limbs_range_constraint_4_shift * SHIFT_12_TO_14 - p_x_low_limbs_range_constraint_tail_shift;
+        tmp_24 *= lagrange_odd;
+        tmp_24 *= scaling_factor;
+        std::get<23>(accumulators) += tmp_24;
+
+        // Contribution 25, range constrain the highest microlimb of second highest P.x limb to be 12 bits
+        auto tmp_25 = p_x_high_limbs_range_constraint_4 * SHIFT_12_TO_14 - p_x_high_limbs_range_constraint_tail;
+        tmp_25 *= lagrange_odd;
+        tmp_25 *= scaling_factor;
+        std::get<24>(accumulators) += tmp_25;
+
+        // Contribution 26, range constrain the highest microilmb of highest P.x limb to be 8 bits (50 % 14 = 8)
+        auto tmp_26 =
+            (p_x_high_limbs_range_constraint_3_shift * SHIFT_8_TO_14 - p_x_high_limbs_range_constraint_4_shift);
+
+        tmp_26 *= lagrange_odd;
+        tmp_26 *= scaling_factor;
+        std::get<25>(accumulators) += tmp_26;
+
+        // Contribution 27, range constrain the highest microlimb of lowest P.y limb to be 12 bits (68 % 14 = 12)
+        auto tmp_27 = p_y_low_limbs_range_constraint_4 * SHIFT_12_TO_14 - p_y_low_limbs_range_constraint_tail;
+        tmp_27 *= lagrange_odd;
+        tmp_27 *= scaling_factor;
+        std::get<26>(accumulators) += tmp_27;
+
+        // Contribution 28, range constrain the highest microlimb of second lowest P.y limb to be 12 bits (68 % 14 = 12)
+        auto tmp_28 =
+            p_y_low_limbs_range_constraint_4_shift * SHIFT_12_TO_14 - p_y_low_limbs_range_constraint_tail_shift;
+        tmp_28 *= lagrange_odd;
+        tmp_28 *= scaling_factor;
+        std::get<27>(accumulators) += tmp_28;
+
+        // Contribution 29, range constrain the highest microlimb of second highest P.y limb to be 12 bits (68 % 14 =
+        // 12)
+        auto tmp_29 = p_y_high_limbs_range_constraint_4 * SHIFT_12_TO_14 - p_y_high_limbs_range_constraint_tail;
+        tmp_29 *= lagrange_odd;
+        tmp_29 *= scaling_factor;
+        std::get<28>(accumulators) += tmp_29;
+
+        // Contribution 30, range constrain the highest microlimb of highest P.y limb to be 8 bits (50 % 14 = 8)
+        auto tmp_30 =
+            (p_y_high_limbs_range_constraint_3_shift * SHIFT_8_TO_14 - p_y_high_limbs_range_constraint_4_shift);
+
+        tmp_30 *= lagrange_odd;
+        tmp_30 *= scaling_factor;
+        std::get<29>(accumulators) += tmp_30;
+
+        // Contribution 31, range constrain the highest microlimb of low z1 limb to be 12 bits (68 % 14 = 12)
+        auto tmp_31 = (z_low_limbs_range_constraint_4 * SHIFT_12_TO_14 - z_low_limbs_range_constraint_tail);
+        tmp_31 *= lagrange_odd;
+        tmp_31 *= scaling_factor;
+        std::get<30>(accumulators) += tmp_31;
+
+        // Contribution 32, range constrain the highest microlimb of low z2 limb to be 12 bits (68 % 14 = 12)
+        auto tmp_32 = (z_low_limbs_range_constraint_4_shift * SHIFT_12_TO_14 - z_low_limbs_range_constraint_tail_shift);
+        tmp_32 *= lagrange_odd;
+        tmp_32 *= scaling_factor;
+        std::get<31>(accumulators) += tmp_32;
+
+        // Contribution 33, range constrain the highest microlimb of high z1 limb to be 4 bits (60 % 14 = 12)
+        auto tmp_33 = (z_high_limbs_range_constraint_4 * SHIFT_4_TO_14 - z_high_limbs_range_constraint_tail);
+        tmp_33 *= lagrange_odd;
+        tmp_33 *= scaling_factor;
+        std::get<32>(accumulators) += tmp_33;
+
+        // Contribution 34, range constrain the highest microlimb of high z2 limb to be 4 bits (60 % 14 = 12)
+        auto tmp_34 =
+            (z_high_limbs_range_constraint_4_shift * SHIFT_4_TO_14 - z_high_limbs_range_constraint_tail_shift);
+        tmp_34 *= lagrange_odd;
+        tmp_34 *= scaling_factor;
+        std::get<33>(accumulators) += tmp_34;
+
+        // Contribution 35, range constrain the highest microlimb of lowest current accumulator limb to be 12 bits (68 %
+        // 14 = 12)
+        auto tmp_35 =
+            (accumulator_low_limbs_range_constraint_4 * SHIFT_12_TO_14 - accumulator_low_limbs_range_constraint_tail);
+        tmp_35 *= lagrange_odd;
+        tmp_35 *= scaling_factor;
+        std::get<34>(accumulators) += tmp_35;
+
+        // Contribution 36, range constrain the highest microlimb of second lowest current accumulator limb to be 12
+        // bits (68 % 14 = 12)
+        auto tmp_36 = (accumulator_low_limbs_range_constraint_4_shift * SHIFT_12_TO_14 -
+                       accumulator_low_limbs_range_constraint_tail_shift);
+        tmp_36 *= lagrange_odd;
+        tmp_36 *= scaling_factor;
+        std::get<35>(accumulators) += tmp_36;
+
+        // Contribution 37, range constrain the highest microlimb of second highest current accumulator limb to be 12
+        // bits (68 % 14 = 12)
+        auto tmp_37 =
+            (accumulator_high_limbs_range_constraint_4 * SHIFT_12_TO_14 - accumulator_high_limbs_range_constraint_tail);
+        tmp_37 *= lagrange_odd;
+        tmp_37 *= scaling_factor;
+        std::get<36>(accumulators) += tmp_37;
+
+        // Contribution 38, range constrain the highest microlimb of highest current accumulator limb to be 8 bits (50 %
+        // 14 = 12)
+        auto tmp_38 = (accumulator_high_limbs_range_constraint_3_shift * SHIFT_8_TO_14 -
+                       accumulator_high_limbs_range_constraint_4_shift);
+        tmp_38 *= lagrange_odd;
+        tmp_38 *= scaling_factor;
+        std::get<37>(accumulators) += tmp_38;
+
+        // Contribution 39, range constrain the highest microlimb of lowest quotient limb to be 12 bits (68 % 14 = 12)
+        auto tmp_39 =
+            (quotient_low_limbs_range_constraint_4 * SHIFT_12_TO_14 - quotient_low_limbs_range_constraint_tail);
+        tmp_39 *= lagrange_odd;
+        tmp_39 *= scaling_factor;
+        std::get<38>(accumulators) += tmp_39;
+
+        // Contribution 40, range constrain the highest microlimb of second lowest quotient limb to be 12 bits (68 % 14
+        // = 12)
+        auto tmp_40 = (quotient_low_limbs_range_constraint_4_shift * SHIFT_12_TO_14 -
+                       quotient_low_limbs_range_constraint_tail_shift);
+        tmp_40 *= lagrange_odd;
+        tmp_40 *= scaling_factor;
+        std::get<39>(accumulators) += tmp_40;
+
+        // Contribution 41, range constrain the highest microlimb of second highest quotient limb to be 12 bits (68 % 14
+        // = 12)
+        auto tmp_41 =
+            (quotient_high_limbs_range_constraint_4 * SHIFT_12_TO_14 - quotient_high_limbs_range_constraint_tail);
+        tmp_41 *= lagrange_odd;
+        tmp_41 *= scaling_factor;
+        std::get<40>(accumulators) += tmp_41;
+
+        // Contribution 42, range constrain the highest microlimb of highest quotient limb to be 10 bits (52 % 14 = 12)
+        auto tmp_42 = (quotient_high_limbs_range_constraint_3_shift * SHIFT_10_TO_14 -
+                       quotient_high_limbs_range_constraint_4_shift);
+        tmp_42 *= lagrange_odd;
+        tmp_42 *= scaling_factor;
+        std::get<41>(accumulators) += tmp_42;
+
+        // Contributions where we decompose initial EccOpQueue values into 68-bit limbs
+
+        // Contribution 43, decompose x_lo
+        auto tmp_43 = (p_x_low_limbs + p_x_low_limbs_shift * LIMB_SHIFT) - x_lo_y_hi;
+        tmp_43 *= lagrange_odd;
+        tmp_43 *= scaling_factor;
+        std::get<42>(accumulators) += tmp_43;
+
+        // Contribution 44, decompose x_hi
+        auto tmp_44 = (p_x_high_limbs + p_x_high_limbs_shift * LIMB_SHIFT) - x_hi_z_1;
+        tmp_44 *= lagrange_odd;
+        tmp_44 *= scaling_factor;
+        std::get<43>(accumulators) += tmp_44;
+        // Contribution 45, decompose y_lo
+        auto tmp_45 = (p_y_low_limbs + p_y_low_limbs_shift * LIMB_SHIFT) - y_lo_z_2;
+        tmp_45 *= lagrange_odd;
+        tmp_45 *= scaling_factor;
+        std::get<44>(accumulators) += tmp_45;
+
+        // Contribution 46, decompose y_hi
+        auto tmp_46 = (p_y_high_limbs + p_y_high_limbs_shift * LIMB_SHIFT) - x_lo_y_hi_shift;
+        tmp_46 *= lagrange_odd;
+        tmp_46 *= scaling_factor;
+        std::get<45>(accumulators) += tmp_46;
+
+        // Contribution 47, decompose z1
+        auto tmp_47 = (z_low_limbs + z_high_limbs * LIMB_SHIFT) - x_hi_z_1_shift;
+        tmp_47 *= lagrange_odd;
+        tmp_47 *= scaling_factor;
+        std::get<46>(accumulators) += tmp_47;
+
+        // Contribution 48, decompose z2
+        auto tmp_48 = (z_low_limbs_shift + z_high_limbs_shift * LIMB_SHIFT) - y_lo_z_2_shift;
+        tmp_48 *= lagrange_odd;
+        tmp_48 *= scaling_factor;
+        std::get<47>(accumulators) += tmp_48;
+    };
+};
+
+template <typename FF>
+using GoblinTranslatorDecompositionRelation = Relation<GoblinTranslatorDecompositionRelationImpl<FF>>;
+
+} // namespace proof_system
diff --git a/barretenberg/cpp/src/barretenberg/proof_system/relations/goblin_translator_relation_consistency.test.cpp b/barretenberg/cpp/src/barretenberg/proof_system/relations/goblin_translator_relation_consistency.test.cpp
index 3523bdd66df6..fd64ed66322f 100644
--- a/barretenberg/cpp/src/barretenberg/proof_system/relations/goblin_translator_relation_consistency.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/proof_system/relations/goblin_translator_relation_consistency.test.cpp
@@ -12,8 +12,10 @@
  *
  */
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/proof_system/relations/decomposition_relation.hpp"
 #include "barretenberg/proof_system/relations/gen_perm_sort_relation.hpp"
 #include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "decomposition_relation.hpp"
 #include <gtest/gtest.h>
 
 using namespace proof_system;
@@ -354,4 +356,553 @@ TEST_F(GoblinTranslatorRelationConsistency, GenPermSortRelation)
     run_test(/*random_inputs=*/true);
 };
 
+TEST_F(GoblinTranslatorRelationConsistency, DecompositionRelation)
+{
+    const auto run_test = [](bool random_inputs) {
+        using Relation = GoblinTranslatorDecompositionRelation<FF>;
+        using RelationValues = typename Relation::RelationValues;
+
+        const InputElements input_elements = random_inputs ? InputElements::get_random() : InputElements::get_special();
+
+        // Get all the wires
+        const auto& p_x_low_limbs_range_constraint_0 = input_elements.p_x_low_limbs_range_constraint_0;
+        const auto& p_x_low_limbs_range_constraint_1 = input_elements.p_x_low_limbs_range_constraint_1;
+        const auto& p_x_low_limbs_range_constraint_2 = input_elements.p_x_low_limbs_range_constraint_2;
+        const auto& p_x_low_limbs_range_constraint_3 = input_elements.p_x_low_limbs_range_constraint_3;
+        const auto& p_x_low_limbs_range_constraint_4 = input_elements.p_x_low_limbs_range_constraint_4;
+        const auto& p_x_low_limbs_range_constraint_tail = input_elements.p_x_low_limbs_range_constraint_tail;
+        const auto& p_x_low_limbs = input_elements.p_x_low_limbs;
+        const auto& p_x_high_limbs_range_constraint_0 = input_elements.p_x_high_limbs_range_constraint_0;
+        const auto& p_x_high_limbs_range_constraint_1 = input_elements.p_x_high_limbs_range_constraint_1;
+        const auto& p_x_high_limbs_range_constraint_2 = input_elements.p_x_high_limbs_range_constraint_2;
+        const auto& p_x_high_limbs_range_constraint_3 = input_elements.p_x_high_limbs_range_constraint_3;
+        const auto& p_x_high_limbs_range_constraint_4 = input_elements.p_x_high_limbs_range_constraint_4;
+        const auto& p_x_high_limbs_range_constraint_tail = input_elements.p_x_high_limbs_range_constraint_tail;
+        const auto& p_x_high_limbs = input_elements.p_x_high_limbs;
+        const auto& p_x_low_limbs_range_constraint_0_shift = input_elements.p_x_low_limbs_range_constraint_0_shift;
+        const auto& p_x_low_limbs_range_constraint_1_shift = input_elements.p_x_low_limbs_range_constraint_1_shift;
+        const auto& p_x_low_limbs_range_constraint_2_shift = input_elements.p_x_low_limbs_range_constraint_2_shift;
+        const auto& p_x_low_limbs_range_constraint_3_shift = input_elements.p_x_low_limbs_range_constraint_3_shift;
+        const auto& p_x_low_limbs_range_constraint_4_shift = input_elements.p_x_low_limbs_range_constraint_4_shift;
+        const auto& p_x_low_limbs_range_constraint_tail_shift =
+            input_elements.p_x_low_limbs_range_constraint_tail_shift;
+        const auto& p_x_low_limbs_shift = input_elements.p_x_low_limbs_shift;
+        const auto& p_x_high_limbs_range_constraint_0_shift = input_elements.p_x_high_limbs_range_constraint_0_shift;
+        const auto& p_x_high_limbs_range_constraint_1_shift = input_elements.p_x_high_limbs_range_constraint_1_shift;
+        const auto& p_x_high_limbs_range_constraint_2_shift = input_elements.p_x_high_limbs_range_constraint_2_shift;
+        const auto& p_x_high_limbs_range_constraint_3_shift = input_elements.p_x_high_limbs_range_constraint_3_shift;
+        const auto& p_x_high_limbs_range_constraint_4_shift = input_elements.p_x_high_limbs_range_constraint_4_shift;
+        const auto& p_x_high_limbs_range_constraint_tail_shift =
+            input_elements.p_x_high_limbs_range_constraint_tail_shift;
+        const auto& p_x_high_limbs_shift = input_elements.p_x_high_limbs_shift;
+        const auto& p_y_low_limbs_range_constraint_0 = input_elements.p_y_low_limbs_range_constraint_0;
+        const auto& p_y_low_limbs_range_constraint_1 = input_elements.p_y_low_limbs_range_constraint_1;
+        const auto& p_y_low_limbs_range_constraint_2 = input_elements.p_y_low_limbs_range_constraint_2;
+        const auto& p_y_low_limbs_range_constraint_3 = input_elements.p_y_low_limbs_range_constraint_3;
+        const auto& p_y_low_limbs_range_constraint_4 = input_elements.p_y_low_limbs_range_constraint_4;
+        const auto& p_y_low_limbs_range_constraint_tail = input_elements.p_y_low_limbs_range_constraint_tail;
+        const auto& p_y_low_limbs = input_elements.p_y_low_limbs;
+        const auto& p_y_high_limbs_range_constraint_0 = input_elements.p_y_high_limbs_range_constraint_0;
+        const auto& p_y_high_limbs_range_constraint_1 = input_elements.p_y_high_limbs_range_constraint_1;
+        const auto& p_y_high_limbs_range_constraint_2 = input_elements.p_y_high_limbs_range_constraint_2;
+        const auto& p_y_high_limbs_range_constraint_3 = input_elements.p_y_high_limbs_range_constraint_3;
+        const auto& p_y_high_limbs_range_constraint_4 = input_elements.p_y_high_limbs_range_constraint_4;
+        const auto& p_y_high_limbs_range_constraint_tail = input_elements.p_y_high_limbs_range_constraint_tail;
+        const auto& p_y_high_limbs = input_elements.p_y_high_limbs;
+        const auto& p_y_low_limbs_range_constraint_0_shift = input_elements.p_y_low_limbs_range_constraint_0_shift;
+        const auto& p_y_low_limbs_range_constraint_1_shift = input_elements.p_y_low_limbs_range_constraint_1_shift;
+        const auto& p_y_low_limbs_range_constraint_2_shift = input_elements.p_y_low_limbs_range_constraint_2_shift;
+        const auto& p_y_low_limbs_range_constraint_3_shift = input_elements.p_y_low_limbs_range_constraint_3_shift;
+        const auto& p_y_low_limbs_range_constraint_4_shift = input_elements.p_y_low_limbs_range_constraint_4_shift;
+        const auto& p_y_low_limbs_range_constraint_tail_shift =
+            input_elements.p_y_low_limbs_range_constraint_tail_shift;
+        const auto& p_y_low_limbs_shift = input_elements.p_y_low_limbs_shift;
+        const auto& p_y_high_limbs_range_constraint_0_shift = input_elements.p_y_high_limbs_range_constraint_0_shift;
+        const auto& p_y_high_limbs_range_constraint_1_shift = input_elements.p_y_high_limbs_range_constraint_1_shift;
+        const auto& p_y_high_limbs_range_constraint_2_shift = input_elements.p_y_high_limbs_range_constraint_2_shift;
+        const auto& p_y_high_limbs_range_constraint_3_shift = input_elements.p_y_high_limbs_range_constraint_3_shift;
+        const auto& p_y_high_limbs_range_constraint_4_shift = input_elements.p_y_high_limbs_range_constraint_4_shift;
+        const auto& p_y_high_limbs_range_constraint_tail_shift =
+            input_elements.p_y_high_limbs_range_constraint_tail_shift;
+        const auto& p_y_high_limbs_shift = input_elements.p_y_high_limbs_shift;
+        const auto& z_low_limbs_range_constraint_0 = input_elements.z_low_limbs_range_constraint_0;
+        const auto& z_low_limbs_range_constraint_1 = input_elements.z_low_limbs_range_constraint_1;
+        const auto& z_low_limbs_range_constraint_2 = input_elements.z_low_limbs_range_constraint_2;
+        const auto& z_low_limbs_range_constraint_3 = input_elements.z_low_limbs_range_constraint_3;
+        const auto& z_low_limbs_range_constraint_4 = input_elements.z_low_limbs_range_constraint_4;
+        const auto& z_low_limbs_range_constraint_tail = input_elements.z_low_limbs_range_constraint_tail;
+        const auto& z_low_limbs = input_elements.z_low_limbs;
+        const auto& z_low_limbs_range_constraint_0_shift = input_elements.z_low_limbs_range_constraint_0_shift;
+        const auto& z_low_limbs_range_constraint_1_shift = input_elements.z_low_limbs_range_constraint_1_shift;
+        const auto& z_low_limbs_range_constraint_2_shift = input_elements.z_low_limbs_range_constraint_2_shift;
+        const auto& z_low_limbs_range_constraint_3_shift = input_elements.z_low_limbs_range_constraint_3_shift;
+        const auto& z_low_limbs_range_constraint_4_shift = input_elements.z_low_limbs_range_constraint_4_shift;
+        const auto& z_low_limbs_range_constraint_tail_shift = input_elements.z_low_limbs_range_constraint_tail_shift;
+        const auto& z_low_limbs_shift = input_elements.z_low_limbs_shift;
+        const auto& z_high_limbs_range_constraint_0 = input_elements.z_high_limbs_range_constraint_0;
+        const auto& z_high_limbs_range_constraint_1 = input_elements.z_high_limbs_range_constraint_1;
+        const auto& z_high_limbs_range_constraint_2 = input_elements.z_high_limbs_range_constraint_2;
+        const auto& z_high_limbs_range_constraint_3 = input_elements.z_high_limbs_range_constraint_3;
+        const auto& z_high_limbs_range_constraint_4 = input_elements.z_high_limbs_range_constraint_4;
+        const auto& z_high_limbs_range_constraint_tail = input_elements.z_high_limbs_range_constraint_tail;
+        const auto& z_high_limbs = input_elements.z_high_limbs;
+        const auto& z_high_limbs_range_constraint_0_shift = input_elements.z_high_limbs_range_constraint_0_shift;
+        const auto& z_high_limbs_range_constraint_1_shift = input_elements.z_high_limbs_range_constraint_1_shift;
+        const auto& z_high_limbs_range_constraint_2_shift = input_elements.z_high_limbs_range_constraint_2_shift;
+        const auto& z_high_limbs_range_constraint_3_shift = input_elements.z_high_limbs_range_constraint_3_shift;
+        const auto& z_high_limbs_range_constraint_4_shift = input_elements.z_high_limbs_range_constraint_4_shift;
+        const auto& z_high_limbs_range_constraint_tail_shift = input_elements.z_high_limbs_range_constraint_tail_shift;
+        const auto& z_high_limbs_shift = input_elements.z_high_limbs_shift;
+        const auto& accumulator_low_limbs_range_constraint_0 = input_elements.accumulator_low_limbs_range_constraint_0;
+        const auto& accumulator_low_limbs_range_constraint_1 = input_elements.accumulator_low_limbs_range_constraint_1;
+        const auto& accumulator_low_limbs_range_constraint_2 = input_elements.accumulator_low_limbs_range_constraint_2;
+        const auto& accumulator_low_limbs_range_constraint_3 = input_elements.accumulator_low_limbs_range_constraint_3;
+        const auto& accumulator_low_limbs_range_constraint_4 = input_elements.accumulator_low_limbs_range_constraint_4;
+        const auto& accumulator_low_limbs_range_constraint_tail =
+            input_elements.accumulator_low_limbs_range_constraint_tail;
+        const auto& accumulator_low_limbs_range_constraint_0_shift =
+            input_elements.accumulator_low_limbs_range_constraint_0_shift;
+        const auto& accumulator_low_limbs_range_constraint_1_shift =
+            input_elements.accumulator_low_limbs_range_constraint_1_shift;
+        const auto& accumulator_low_limbs_range_constraint_2_shift =
+            input_elements.accumulator_low_limbs_range_constraint_2_shift;
+        const auto& accumulator_low_limbs_range_constraint_3_shift =
+            input_elements.accumulator_low_limbs_range_constraint_3_shift;
+        const auto& accumulator_low_limbs_range_constraint_4_shift =
+            input_elements.accumulator_low_limbs_range_constraint_4_shift;
+        const auto& accumulator_low_limbs_range_constraint_tail_shift =
+            input_elements.accumulator_low_limbs_range_constraint_tail_shift;
+        const auto& accumulator_high_limbs_range_constraint_0 =
+            input_elements.accumulator_high_limbs_range_constraint_0;
+        const auto& accumulator_high_limbs_range_constraint_1 =
+            input_elements.accumulator_high_limbs_range_constraint_1;
+        const auto& accumulator_high_limbs_range_constraint_2 =
+            input_elements.accumulator_high_limbs_range_constraint_2;
+        const auto& accumulator_high_limbs_range_constraint_3 =
+            input_elements.accumulator_high_limbs_range_constraint_3;
+        const auto& accumulator_high_limbs_range_constraint_4 =
+            input_elements.accumulator_high_limbs_range_constraint_4;
+        const auto& accumulator_high_limbs_range_constraint_tail =
+            input_elements.accumulator_high_limbs_range_constraint_tail;
+        const auto& accumulator_high_limbs_range_constraint_0_shift =
+            input_elements.accumulator_high_limbs_range_constraint_0_shift;
+        const auto& accumulator_high_limbs_range_constraint_1_shift =
+            input_elements.accumulator_high_limbs_range_constraint_1_shift;
+        const auto& accumulator_high_limbs_range_constraint_2_shift =
+            input_elements.accumulator_high_limbs_range_constraint_2_shift;
+        const auto& accumulator_high_limbs_range_constraint_3_shift =
+            input_elements.accumulator_high_limbs_range_constraint_3_shift;
+        const auto& accumulator_high_limbs_range_constraint_4_shift =
+            input_elements.accumulator_high_limbs_range_constraint_4_shift;
+        const auto& accumulator_high_limbs_range_constraint_tail_shift =
+            input_elements.accumulator_high_limbs_range_constraint_tail_shift;
+        const auto& accumulators_binary_limbs_0 = input_elements.accumulators_binary_limbs_0;
+        const auto& accumulators_binary_limbs_1 = input_elements.accumulators_binary_limbs_1;
+        const auto& accumulators_binary_limbs_2 = input_elements.accumulators_binary_limbs_2;
+        const auto& accumulators_binary_limbs_3 = input_elements.accumulators_binary_limbs_3;
+        const auto& quotient_low_limbs_range_constraint_0 = input_elements.quotient_low_limbs_range_constraint_0;
+        const auto& quotient_low_limbs_range_constraint_1 = input_elements.quotient_low_limbs_range_constraint_1;
+        const auto& quotient_low_limbs_range_constraint_2 = input_elements.quotient_low_limbs_range_constraint_2;
+        const auto& quotient_low_limbs_range_constraint_3 = input_elements.quotient_low_limbs_range_constraint_3;
+        const auto& quotient_low_limbs_range_constraint_4 = input_elements.quotient_low_limbs_range_constraint_4;
+        const auto& quotient_low_limbs_range_constraint_tail = input_elements.quotient_low_limbs_range_constraint_tail;
+        const auto& quotient_low_limbs_range_constraint_0_shift =
+            input_elements.quotient_low_limbs_range_constraint_0_shift;
+        const auto& quotient_low_limbs_range_constraint_1_shift =
+            input_elements.quotient_low_limbs_range_constraint_1_shift;
+        const auto& quotient_low_limbs_range_constraint_2_shift =
+            input_elements.quotient_low_limbs_range_constraint_2_shift;
+        const auto& quotient_low_limbs_range_constraint_3_shift =
+            input_elements.quotient_low_limbs_range_constraint_3_shift;
+        const auto& quotient_low_limbs_range_constraint_4_shift =
+            input_elements.quotient_low_limbs_range_constraint_4_shift;
+        const auto& quotient_low_limbs_range_constraint_tail_shift =
+            input_elements.quotient_low_limbs_range_constraint_tail_shift;
+        const auto& quotient_high_limbs_range_constraint_0 = input_elements.quotient_high_limbs_range_constraint_0;
+        const auto& quotient_high_limbs_range_constraint_1 = input_elements.quotient_high_limbs_range_constraint_1;
+        const auto& quotient_high_limbs_range_constraint_2 = input_elements.quotient_high_limbs_range_constraint_2;
+        const auto& quotient_high_limbs_range_constraint_3 = input_elements.quotient_high_limbs_range_constraint_3;
+        const auto& quotient_high_limbs_range_constraint_4 = input_elements.quotient_high_limbs_range_constraint_4;
+        const auto& quotient_high_limbs_range_constraint_tail =
+            input_elements.quotient_high_limbs_range_constraint_tail;
+        const auto& quotient_high_limbs_range_constraint_0_shift =
+            input_elements.quotient_high_limbs_range_constraint_0_shift;
+        const auto& quotient_high_limbs_range_constraint_1_shift =
+            input_elements.quotient_high_limbs_range_constraint_1_shift;
+        const auto& quotient_high_limbs_range_constraint_2_shift =
+            input_elements.quotient_high_limbs_range_constraint_2_shift;
+        const auto& quotient_high_limbs_range_constraint_3_shift =
+            input_elements.quotient_high_limbs_range_constraint_3_shift;
+        const auto& quotient_high_limbs_range_constraint_4_shift =
+            input_elements.quotient_high_limbs_range_constraint_4_shift;
+        const auto& quotient_high_limbs_range_constraint_tail_shift =
+            input_elements.quotient_high_limbs_range_constraint_tail_shift;
+        const auto& quotient_low_binary_limbs = input_elements.quotient_low_binary_limbs;
+        const auto& quotient_low_binary_limbs_shift = input_elements.quotient_low_binary_limbs_shift;
+        const auto& quotient_high_binary_limbs = input_elements.quotient_high_binary_limbs;
+        const auto& quotient_high_binary_limbs_shift = input_elements.quotient_high_binary_limbs_shift;
+        const auto& relation_wide_limbs_range_constraint_0 = input_elements.relation_wide_limbs_range_constraint_0;
+        const auto& relation_wide_limbs_range_constraint_1 = input_elements.relation_wide_limbs_range_constraint_1;
+        const auto& relation_wide_limbs_range_constraint_2 = input_elements.relation_wide_limbs_range_constraint_2;
+        const auto& relation_wide_limbs_range_constraint_3 = input_elements.relation_wide_limbs_range_constraint_3;
+        const auto& relation_wide_limbs_range_constraint_0_shift =
+            input_elements.relation_wide_limbs_range_constraint_0_shift;
+        const auto& relation_wide_limbs_range_constraint_1_shift =
+            input_elements.relation_wide_limbs_range_constraint_1_shift;
+        const auto& relation_wide_limbs_range_constraint_2_shift =
+            input_elements.relation_wide_limbs_range_constraint_2_shift;
+        const auto& relation_wide_limbs_range_constraint_3_shift =
+            input_elements.relation_wide_limbs_range_constraint_3_shift;
+        const auto& relation_wide_limbs = input_elements.relation_wide_limbs;
+        const auto& relation_wide_limbs_shift = input_elements.relation_wide_limbs_shift;
+
+        const auto& x_lo_y_hi = input_elements.x_lo_y_hi;
+        const auto& x_hi_z_1 = input_elements.x_hi_z_1;
+        const auto& y_lo_z_2 = input_elements.y_lo_z_2;
+        const auto& x_lo_y_hi_shift = input_elements.x_lo_y_hi_shift;
+        const auto& x_hi_z_1_shift = input_elements.x_hi_z_1_shift;
+        const auto& y_lo_z_2_shift = input_elements.y_lo_z_2_shift;
+
+        const auto& lagrange_odd = input_elements.lagrange_odd;
+
+        RelationValues expected_values;
+
+        const auto parameters = RelationParameters<FF>::get_random();
+
+        const size_t NUM_MICRO_LIMB_BITS = 14;
+        const size_t NUM_LIMB_BITS = 68;
+        const auto MICRO_LIMB_SHIFT = FF(uint256_t(1) << NUM_MICRO_LIMB_BITS);
+        const auto MICRO_LIMB_SHIFTx2 = MICRO_LIMB_SHIFT * MICRO_LIMB_SHIFT;
+        const auto MICRO_LIMB_SHIFTx3 = MICRO_LIMB_SHIFTx2 * MICRO_LIMB_SHIFT;
+        const auto MICRO_LIMB_SHIFTx4 = MICRO_LIMB_SHIFTx3 * MICRO_LIMB_SHIFT;
+        const auto MICRO_LIMB_SHIFTx5 = MICRO_LIMB_SHIFTx4 * MICRO_LIMB_SHIFT;
+
+        const auto SHIFT_10_TO_14 = FF(1 << 4);
+        const auto SHIFT_12_TO_14 = FF(1 << 2);
+        const auto SHIFT_4_TO_14 = FF(1 << 10);
+        const auto SHIFT_8_TO_14 = FF(1 << 6);
+        const auto LIMB_SHIFT = FF(uint256_t(1) << NUM_LIMB_BITS);
+
+        // All decomposition happen only at odd indices, so we use lagrange odd
+        /**
+         * @brief Check decomposition of a relation limb. Relation limbs are 84 bits, so the decompositon takes 6
+         * 14-bit microlimbs
+         *
+         */
+        auto check_relation_limb_decomposition = [MICRO_LIMB_SHIFT,
+                                                  MICRO_LIMB_SHIFTx2,
+                                                  MICRO_LIMB_SHIFTx3,
+                                                  MICRO_LIMB_SHIFTx4,
+                                                  MICRO_LIMB_SHIFTx5,
+                                                  lagrange_odd](auto& micro_limb_0,
+                                                                auto& micro_limb_1,
+                                                                auto& micro_limb_2,
+                                                                auto& micro_limb_3,
+                                                                auto& micro_limb_4,
+                                                                auto& micro_limb_5,
+                                                                auto& decomposed_limb) {
+            return (micro_limb_0 + micro_limb_1 * MICRO_LIMB_SHIFT + micro_limb_2 * MICRO_LIMB_SHIFTx2 +
+                    micro_limb_3 * MICRO_LIMB_SHIFTx3 + micro_limb_4 * MICRO_LIMB_SHIFTx4 +
+                    micro_limb_5 * MICRO_LIMB_SHIFTx5 - decomposed_limb) *
+                   lagrange_odd;
+        };
+
+        /**
+         * @brief Check the decomposition of a standard limb. Standard limbs are 68 bits, so we decompose them into
+         * 5 14-bit microlimbs
+         *
+         */
+        auto check_standard_limb_decomposition =
+            [MICRO_LIMB_SHIFT, MICRO_LIMB_SHIFTx2, MICRO_LIMB_SHIFTx3, MICRO_LIMB_SHIFTx4, lagrange_odd](
+                auto& micro_limb_0,
+                auto& micro_limb_1,
+                auto& micro_limb_2,
+                auto& micro_limb_3,
+                auto& micro_limb_4,
+                auto& decomposed_limb) {
+                return (micro_limb_0 + micro_limb_1 * MICRO_LIMB_SHIFT + micro_limb_2 * MICRO_LIMB_SHIFTx2 +
+                        micro_limb_3 * MICRO_LIMB_SHIFTx3 + micro_limb_4 * MICRO_LIMB_SHIFTx4 - decomposed_limb) *
+                       lagrange_odd;
+            };
+
+        /**
+         * @brief Check the decomposition of a standard top limb. Standard top limb is 50 bits (254 = 68 * 3 + 50)
+         *
+         */
+        auto check_standard_top_limb_decomposition =
+            [MICRO_LIMB_SHIFT, MICRO_LIMB_SHIFTx2, MICRO_LIMB_SHIFTx3, lagrange_odd](
+                auto& micro_limb_0, auto& micro_limb_1, auto& micro_limb_2, auto& micro_limb_3, auto& decomposed_limb) {
+                return (micro_limb_0 + micro_limb_1 * MICRO_LIMB_SHIFT + micro_limb_2 * MICRO_LIMB_SHIFTx2 +
+                        micro_limb_3 * MICRO_LIMB_SHIFTx3 - decomposed_limb) *
+                       lagrange_odd;
+            };
+
+        /**
+         * @brief Ensure that the last microlimb of a standard limb decomposition is 12 bits by checking a shifted
+         * version.
+         *
+         */
+        auto check_standard_tail_micro_limb_correctness = [SHIFT_12_TO_14, lagrange_odd](auto& nonshifted_micro_limb,
+                                                                                         auto shifted_micro_limb) {
+            return (nonshifted_micro_limb * SHIFT_12_TO_14 - shifted_micro_limb) * lagrange_odd;
+        };
+
+        /**
+         * @brief Ensure that the last microlimb of a standard top limb decomposition is 8 bits by checking a
+         * shifted version.
+         *
+         */
+        auto check_top_tail_micro_limb_correctness = [SHIFT_8_TO_14, lagrange_odd](auto& nonshifted_micro_limb,
+                                                                                   auto shifted_micro_limb) {
+            return (nonshifted_micro_limb * SHIFT_8_TO_14 - shifted_micro_limb) * lagrange_odd;
+        };
+
+        /**
+         * @brief Ensure that the last microlimb of z top limb decomposition is 4 bits by checking a shifted
+         * version.
+         *
+         */
+        auto check_z_top_tail_micro_limb_correctness = [SHIFT_4_TO_14, lagrange_odd](auto& nonshifted_micro_limb,
+                                                                                     auto shifted_micro_limb) {
+            return (nonshifted_micro_limb * SHIFT_4_TO_14 - shifted_micro_limb) * lagrange_odd;
+        };
+
+        /**
+         * @brief Ensure that the last microlimb of quotient top limb decomposition is 10 bits by checking a shifted
+         * version.
+         *
+         */
+        auto check_quotient_top_tail_micro_limb_correctness =
+            [SHIFT_10_TO_14, lagrange_odd](auto& nonshifted_micro_limb, auto shifted_micro_limb) {
+                return (nonshifted_micro_limb * SHIFT_10_TO_14 - shifted_micro_limb) * lagrange_odd;
+            };
+
+        /**
+         * @brief Check decomposition of wide 128-bit limbs into two 68-bit limbs.
+         *
+         */
+        auto check_wide_limb_into_regular_limb_correctness =
+            [LIMB_SHIFT, lagrange_odd](auto& low_limb, auto& high_limb, auto& wide_limb) {
+                return (low_limb + high_limb * LIMB_SHIFT - wide_limb) * lagrange_odd;
+            };
+
+        // Check decomposition 50-72 bit limbs into microlimbs
+        expected_values[0] = check_standard_limb_decomposition(p_x_low_limbs_range_constraint_0,
+                                                               p_x_low_limbs_range_constraint_1,
+                                                               p_x_low_limbs_range_constraint_2,
+                                                               p_x_low_limbs_range_constraint_3,
+                                                               p_x_low_limbs_range_constraint_4,
+                                                               p_x_low_limbs);
+        expected_values[1] = check_standard_limb_decomposition(p_x_low_limbs_range_constraint_0_shift,
+                                                               p_x_low_limbs_range_constraint_1_shift,
+                                                               p_x_low_limbs_range_constraint_2_shift,
+                                                               p_x_low_limbs_range_constraint_3_shift,
+                                                               p_x_low_limbs_range_constraint_4_shift,
+                                                               p_x_low_limbs_shift);
+        expected_values[2] = check_standard_limb_decomposition(p_x_high_limbs_range_constraint_0,
+                                                               p_x_high_limbs_range_constraint_1,
+                                                               p_x_high_limbs_range_constraint_2,
+                                                               p_x_high_limbs_range_constraint_3,
+                                                               p_x_high_limbs_range_constraint_4,
+                                                               p_x_high_limbs);
+        expected_values[3] = check_standard_top_limb_decomposition(p_x_high_limbs_range_constraint_0_shift,
+                                                                   p_x_high_limbs_range_constraint_1_shift,
+                                                                   p_x_high_limbs_range_constraint_2_shift,
+                                                                   p_x_high_limbs_range_constraint_3_shift,
+                                                                   p_x_high_limbs_shift);
+
+        expected_values[4] = check_standard_limb_decomposition(p_y_low_limbs_range_constraint_0,
+                                                               p_y_low_limbs_range_constraint_1,
+                                                               p_y_low_limbs_range_constraint_2,
+                                                               p_y_low_limbs_range_constraint_3,
+                                                               p_y_low_limbs_range_constraint_4,
+                                                               p_y_low_limbs);
+        expected_values[5] = check_standard_limb_decomposition(p_y_low_limbs_range_constraint_0_shift,
+                                                               p_y_low_limbs_range_constraint_1_shift,
+                                                               p_y_low_limbs_range_constraint_2_shift,
+                                                               p_y_low_limbs_range_constraint_3_shift,
+                                                               p_y_low_limbs_range_constraint_4_shift,
+                                                               p_y_low_limbs_shift);
+        expected_values[6] = check_standard_limb_decomposition(p_y_high_limbs_range_constraint_0,
+                                                               p_y_high_limbs_range_constraint_1,
+                                                               p_y_high_limbs_range_constraint_2,
+                                                               p_y_high_limbs_range_constraint_3,
+                                                               p_y_high_limbs_range_constraint_4,
+                                                               p_y_high_limbs);
+        expected_values[7] = check_standard_top_limb_decomposition(p_y_high_limbs_range_constraint_0_shift,
+                                                                   p_y_high_limbs_range_constraint_1_shift,
+                                                                   p_y_high_limbs_range_constraint_2_shift,
+                                                                   p_y_high_limbs_range_constraint_3_shift,
+                                                                   p_y_high_limbs_shift);
+        expected_values[8] = check_standard_limb_decomposition(z_low_limbs_range_constraint_0,
+                                                               z_low_limbs_range_constraint_1,
+                                                               z_low_limbs_range_constraint_2,
+                                                               z_low_limbs_range_constraint_3,
+                                                               z_low_limbs_range_constraint_4,
+                                                               z_low_limbs);
+        expected_values[9] = check_standard_limb_decomposition(z_low_limbs_range_constraint_0_shift,
+                                                               z_low_limbs_range_constraint_1_shift,
+                                                               z_low_limbs_range_constraint_2_shift,
+                                                               z_low_limbs_range_constraint_3_shift,
+                                                               z_low_limbs_range_constraint_4_shift,
+                                                               z_low_limbs_shift);
+        expected_values[10] = check_standard_limb_decomposition(z_high_limbs_range_constraint_0,
+                                                                z_high_limbs_range_constraint_1,
+                                                                z_high_limbs_range_constraint_2,
+                                                                z_high_limbs_range_constraint_3,
+                                                                z_high_limbs_range_constraint_4,
+                                                                z_high_limbs);
+        expected_values[11] = check_standard_limb_decomposition(z_high_limbs_range_constraint_0_shift,
+                                                                z_high_limbs_range_constraint_1_shift,
+                                                                z_high_limbs_range_constraint_2_shift,
+                                                                z_high_limbs_range_constraint_3_shift,
+                                                                z_high_limbs_range_constraint_4_shift,
+                                                                z_high_limbs_shift);
+        expected_values[12] = check_standard_limb_decomposition(accumulator_low_limbs_range_constraint_0,
+                                                                accumulator_low_limbs_range_constraint_1,
+                                                                accumulator_low_limbs_range_constraint_2,
+                                                                accumulator_low_limbs_range_constraint_3,
+                                                                accumulator_low_limbs_range_constraint_4,
+                                                                accumulators_binary_limbs_0);
+        expected_values[13] = check_standard_limb_decomposition(accumulator_low_limbs_range_constraint_0_shift,
+                                                                accumulator_low_limbs_range_constraint_1_shift,
+                                                                accumulator_low_limbs_range_constraint_2_shift,
+                                                                accumulator_low_limbs_range_constraint_3_shift,
+                                                                accumulator_low_limbs_range_constraint_4_shift,
+                                                                accumulators_binary_limbs_1);
+        expected_values[14] = check_standard_limb_decomposition(accumulator_high_limbs_range_constraint_0,
+                                                                accumulator_high_limbs_range_constraint_1,
+                                                                accumulator_high_limbs_range_constraint_2,
+                                                                accumulator_high_limbs_range_constraint_3,
+                                                                accumulator_high_limbs_range_constraint_4,
+                                                                accumulators_binary_limbs_2);
+        expected_values[15] = check_standard_top_limb_decomposition(accumulator_high_limbs_range_constraint_0_shift,
+                                                                    accumulator_high_limbs_range_constraint_1_shift,
+                                                                    accumulator_high_limbs_range_constraint_2_shift,
+                                                                    accumulator_high_limbs_range_constraint_3_shift,
+                                                                    accumulators_binary_limbs_3);
+        expected_values[16] = check_standard_limb_decomposition(quotient_low_limbs_range_constraint_0,
+                                                                quotient_low_limbs_range_constraint_1,
+                                                                quotient_low_limbs_range_constraint_2,
+                                                                quotient_low_limbs_range_constraint_3,
+                                                                quotient_low_limbs_range_constraint_4,
+                                                                quotient_low_binary_limbs);
+        expected_values[17] = check_standard_limb_decomposition(quotient_low_limbs_range_constraint_0_shift,
+                                                                quotient_low_limbs_range_constraint_1_shift,
+                                                                quotient_low_limbs_range_constraint_2_shift,
+                                                                quotient_low_limbs_range_constraint_3_shift,
+                                                                quotient_low_limbs_range_constraint_4_shift,
+                                                                quotient_low_binary_limbs_shift);
+        expected_values[18] = check_standard_limb_decomposition(quotient_high_limbs_range_constraint_0,
+                                                                quotient_high_limbs_range_constraint_1,
+                                                                quotient_high_limbs_range_constraint_2,
+                                                                quotient_high_limbs_range_constraint_3,
+                                                                quotient_high_limbs_range_constraint_4,
+                                                                quotient_high_binary_limbs);
+        expected_values[19] = check_standard_top_limb_decomposition(quotient_high_limbs_range_constraint_0_shift,
+                                                                    quotient_high_limbs_range_constraint_1_shift,
+                                                                    quotient_high_limbs_range_constraint_2_shift,
+                                                                    quotient_high_limbs_range_constraint_3_shift,
+                                                                    quotient_high_binary_limbs_shift);
+
+        expected_values[20] = check_relation_limb_decomposition(relation_wide_limbs_range_constraint_0,
+                                                                relation_wide_limbs_range_constraint_1,
+                                                                relation_wide_limbs_range_constraint_2,
+                                                                relation_wide_limbs_range_constraint_3,
+                                                                p_x_high_limbs_range_constraint_tail_shift,
+                                                                accumulator_high_limbs_range_constraint_tail_shift,
+                                                                relation_wide_limbs);
+        expected_values[21] = check_relation_limb_decomposition(relation_wide_limbs_range_constraint_0_shift,
+                                                                relation_wide_limbs_range_constraint_1_shift,
+                                                                relation_wide_limbs_range_constraint_2_shift,
+                                                                relation_wide_limbs_range_constraint_3_shift,
+                                                                p_y_high_limbs_range_constraint_tail_shift,
+                                                                quotient_high_limbs_range_constraint_tail_shift,
+                                                                relation_wide_limbs_shift);
+
+        // Contributions enforcing tail range constraints (range constraints less than 14 bits)
+        expected_values[22] = check_standard_tail_micro_limb_correctness(p_x_low_limbs_range_constraint_4,
+                                                                         p_x_low_limbs_range_constraint_tail);
+
+        expected_values[23] = check_standard_tail_micro_limb_correctness(p_x_low_limbs_range_constraint_4_shift,
+                                                                         p_x_low_limbs_range_constraint_tail_shift);
+
+        expected_values[24] = check_standard_tail_micro_limb_correctness(p_x_high_limbs_range_constraint_4,
+                                                                         p_x_high_limbs_range_constraint_tail);
+
+        expected_values[25] = check_top_tail_micro_limb_correctness(p_x_high_limbs_range_constraint_3_shift,
+                                                                    p_x_high_limbs_range_constraint_4_shift);
+
+        expected_values[26] = check_standard_tail_micro_limb_correctness(p_y_low_limbs_range_constraint_4,
+                                                                         p_y_low_limbs_range_constraint_tail);
+
+        expected_values[27] = check_standard_tail_micro_limb_correctness(p_y_low_limbs_range_constraint_4_shift,
+                                                                         p_y_low_limbs_range_constraint_tail_shift);
+
+        expected_values[28] = check_standard_tail_micro_limb_correctness(p_y_high_limbs_range_constraint_4,
+                                                                         p_y_high_limbs_range_constraint_tail);
+
+        expected_values[29] = check_top_tail_micro_limb_correctness(p_y_high_limbs_range_constraint_3_shift,
+                                                                    p_y_high_limbs_range_constraint_4_shift);
+
+        expected_values[30] = check_standard_tail_micro_limb_correctness(z_low_limbs_range_constraint_4,
+                                                                         z_low_limbs_range_constraint_tail);
+
+        expected_values[31] = check_standard_tail_micro_limb_correctness(z_low_limbs_range_constraint_4_shift,
+                                                                         z_low_limbs_range_constraint_tail_shift);
+
+        expected_values[32] = check_z_top_tail_micro_limb_correctness(z_high_limbs_range_constraint_4,
+                                                                      z_high_limbs_range_constraint_tail);
+
+        expected_values[33] = check_z_top_tail_micro_limb_correctness(z_high_limbs_range_constraint_4_shift,
+                                                                      z_high_limbs_range_constraint_tail_shift);
+
+        expected_values[34] = check_standard_tail_micro_limb_correctness(accumulator_low_limbs_range_constraint_4,
+                                                                         accumulator_low_limbs_range_constraint_tail);
+        expected_values[35] = check_standard_tail_micro_limb_correctness(
+            accumulator_low_limbs_range_constraint_4_shift, accumulator_low_limbs_range_constraint_tail_shift);
+
+        expected_values[36] = check_standard_tail_micro_limb_correctness(accumulator_high_limbs_range_constraint_4,
+                                                                         accumulator_high_limbs_range_constraint_tail);
+
+        expected_values[37] = check_top_tail_micro_limb_correctness(accumulator_high_limbs_range_constraint_3_shift,
+                                                                    accumulator_high_limbs_range_constraint_4_shift);
+
+        expected_values[38] = check_standard_tail_micro_limb_correctness(quotient_low_limbs_range_constraint_4,
+                                                                         quotient_low_limbs_range_constraint_tail);
+
+        expected_values[39] = check_standard_tail_micro_limb_correctness(
+            quotient_low_limbs_range_constraint_4_shift, quotient_low_limbs_range_constraint_tail_shift);
+
+        expected_values[40] = check_standard_tail_micro_limb_correctness(quotient_high_limbs_range_constraint_4,
+                                                                         quotient_high_limbs_range_constraint_tail);
+
+        expected_values[41] = check_quotient_top_tail_micro_limb_correctness(
+            quotient_high_limbs_range_constraint_3_shift, quotient_high_limbs_range_constraint_4_shift);
+
+        // Constraints for decomposition of EccOpQueue values
+
+        expected_values[42] =
+            check_wide_limb_into_regular_limb_correctness(p_x_low_limbs, p_x_low_limbs_shift, x_lo_y_hi);
+
+        expected_values[43] =
+            check_wide_limb_into_regular_limb_correctness(p_x_high_limbs, p_x_high_limbs_shift, x_hi_z_1);
+
+        expected_values[44] =
+            check_wide_limb_into_regular_limb_correctness(p_y_low_limbs, p_y_low_limbs_shift, y_lo_z_2);
+
+        expected_values[45] =
+            check_wide_limb_into_regular_limb_correctness(p_y_high_limbs, p_y_high_limbs_shift, x_lo_y_hi_shift);
+
+        expected_values[46] = check_wide_limb_into_regular_limb_correctness(z_low_limbs, z_high_limbs, x_hi_z_1_shift);
+
+        expected_values[47] =
+            check_wide_limb_into_regular_limb_correctness(z_low_limbs_shift, z_high_limbs_shift, y_lo_z_2_shift);
+
+        validate_relation_execution<Relation>(expected_values, input_elements, parameters);
+    };
+    run_test(/*random_inputs=*/false);
+    run_test(/*random_inputs=*/true);
+};
+
 } // namespace proof_system::ultra_relation_consistency_tests