From 893f6c30920b6ccff9225443027510b061223b37 Mon Sep 17 00:00:00 2001
From: freddi8e <152241286+freddi8e@users.noreply.github.com>
Date: Wed, 8 Jan 2025 22:32:23 +0800
Subject: [PATCH] fix issue 157 (#163)

* fix non fixed points

* refactor ell

* remove _stable

* fix test test_wrong_proof_and_modify_intermediates

* fix hinted_ell_by_constant_affine

* fix as comment

---------

Co-authored-by: freddie <freddie@bitlayer.ltd>
---
 bitvm/src/bn254/fp254impl.rs                  |  29 --
 bitvm/src/bn254/fq2.rs                        |  33 ---
 bitvm/src/bn254/pairing.rs                    | 112 ++++++-
 bitvm/src/bn254/utils.rs                      | 280 ++++++++++--------
 bitvm/src/chunker/chunk_accumulator.rs        |  83 ++++--
 bitvm/src/chunker/chunk_evaluate_line.rs      |  83 +++++-
 bitvm/src/chunker/chunk_groth16_verifier.rs   |  27 +-
 bitvm/src/chunker/chunk_hinted_accumulator.rs |  29 +-
 bitvm/src/chunker/chunk_non_fixed_point.rs    | 174 +++++------
 9 files changed, 524 insertions(+), 326 deletions(-)

diff --git a/bitvm/src/bn254/fp254impl.rs b/bitvm/src/bn254/fp254impl.rs
index 1dc73aa31..27a39dee9 100644
--- a/bitvm/src/bn254/fp254impl.rs
+++ b/bitvm/src/bn254/fp254impl.rs
@@ -625,35 +625,6 @@ pub trait Fp254Impl {
         (script, hints)
     }
 
-    // TODO: Optimize by using the constant feature
-    fn hinted_mul_by_constant_stable(
-        a: ark_bn254::Fq,
-        constant: &ark_bn254::Fq,
-    ) -> (Script, Vec<Hint>) {
-        let mut hints = Vec::new();
-        let x = BigInt::from_str(&a.to_string()).unwrap();
-        let y = BigInt::from_str(&constant.to_string()).unwrap();
-        let modulus = &Fq::modulus_as_bigint();
-        let q = (x * y) / modulus;
-
-        let script = script! {
-            for _ in 0..Self::N_LIMBS {
-                OP_DEPTH OP_1SUB OP_ROLL // hints
-            }
-            // { fq_push(ark_bn254::Fq::from_str(&q.to_string()).unwrap()) }
-            { Fq::roll(1) }
-            //{ fq_push_not_montgomery(*constant) }
-            for _ in 0..Self::N_LIMBS {
-                OP_DEPTH OP_1SUB OP_ROLL // hints
-            }
-            { Fq::tmul() }
-        };
-        hints.push(Hint::BigIntegerTmulLC1(q));
-        hints.push(Hint::Fq(*constant));
-
-        (script, hints)
-    }
-
     fn hinted_mul_keep_element(
         mut a_depth: u32,
         mut a: ark_bn254::Fq,
diff --git a/bitvm/src/bn254/fq2.rs b/bitvm/src/bn254/fq2.rs
index e713682a9..94e3821cb 100644
--- a/bitvm/src/bn254/fq2.rs
+++ b/bitvm/src/bn254/fq2.rs
@@ -398,39 +398,6 @@ impl Fq2 {
         (script, hints)
     }
 
-    pub fn hinted_mul_by_constant_stable(a: ark_bn254::Fq2, constant: &ark_bn254::Fq2) -> (Script, Vec<Hint>) {
-        let mut hints = Vec::new();
-
-        let (hinted_script1, hint1) = Fq::hinted_mul_by_constant_stable(a.c0, &constant.c0);
-        let (hinted_script2, hint2) = Fq::hinted_mul_by_constant_stable(a.c1, &constant.c1);
-        let (hinted_script3, hint3) = Fq::hinted_mul_by_constant_stable(a.c0+a.c1, &(constant.c0+constant.c1));
-
-        let mut script = script! {};
-        let script_lines = [
-            Fq::copy(1),
-            hinted_script1,
-            Fq::copy(1),
-            hinted_script2,
-            Fq::add(3, 2),
-            hinted_script3,
-            Fq::copy(2),
-            Fq::copy(2),
-            Fq::add(1, 0),
-            Fq::sub(1, 0),
-            Fq::sub(2, 1),
-            Fq::roll(1),
-        ];
-        for script_line in script_lines {
-            script = script.push_script(script_line.compile());
-        }
-
-        hints.extend(hint1);
-        hints.extend(hint2);
-        hints.extend(hint3);
-
-        (script, hints)
-    }
-
     pub fn toaltstack() -> Script {
         script! {
             { Fq::toaltstack() }
diff --git a/bitvm/src/bn254/pairing.rs b/bitvm/src/bn254/pairing.rs
index cadf4f417..e33f13d44 100644
--- a/bitvm/src/bn254/pairing.rs
+++ b/bitvm/src/bn254/pairing.rs
@@ -845,15 +845,46 @@ impl Pairing {
                     script_lines.push(Fq2::copy(2));
                     script_lines.push(Fq2::copy(2));
                     // [beta_12(2), beta_13(2), beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), c(12), c_inv(12), wi(12), T4(4), T4(4) | f(12)]
+
+                    // -- push c3,c4 to stack  
+                    script_lines.push(fq2_push_not_montgomery(line_coeffs[num_lines - (i + 2)][j][0].1)); 
+                    script_lines.push(fq2_push_not_montgomery(line_coeffs[num_lines - (i + 2)][j][0].2));     
+                    // [...T4(4),T4(4),C3(2),C4(2)]
+                    // -- move t4 to stack top 
+                    script_lines.push(Fq2::roll(6));
+                    script_lines.push(Fq2::roll(6));
+                    // -- [...T4(4),C3(2),C4(2),T4(4)]
                     script_lines.push(scripts_iter.next().unwrap()); // check_tangent_line(line_coeffs[num_lines - (i + 2)][j][0].1, line_coeffs[num_lines - (i + 2)][j][0].2)
                                                                      // [beta_12(2), beta_13(2), beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), c(12), c_inv(12), wi(12), T4(4) | f(12)]
 
+                    // -- [...T4(4),c3(2),c4(2)]
+                    // -- move c3,c4 to alt stack 
+                    script_lines.push(Fq2::toaltstack());
+                    script_lines.push(Fq2::toaltstack());
+                    // -- [...T4(4), | c3(2),c4(2),f(12)]
+                    // 
                     // update T4
                     // drop T4.y, leave T4.x
                     script_lines.push(Fq2::drop());
+
+                    // -- [...T4.x(2),| c3(2),c4(2),fq(12)]
+                    // -- move c3 c4 to stack   
+                    script_lines.push(Fq2::fromaltstack());
+                    script_lines.push(Fq2::fromaltstack());
+                    // -- [...T4.x(2),c3(2),c4(2)|f(12)]
+                    // -- move T4.x(2) to stack top 
+                    script_lines.push(Fq2::roll(4));
+                    // -- [...,c3(2),c4(2),T4.x(2)|f(12)]
                     // [beta_12(2), beta_13(2), beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), c(12), c_inv(12), wi(12), T4.x(2) | f(12)]
                     script_lines.push(scripts_iter.next().unwrap()); // affine_double_line(line_coeffs[num_lines - (i + 2)][j][0].1, line_coeffs[num_lines - (i + 2)][j][0].2)
                                                                      // [beta_12(2), beta_13(2), beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), c(12), c_inv(12), wi(12), T4(4) | f(12)]
+                    // -- [...c3(2),c4(2),T4(4)|f(12)]
+                    // -- drop c3,c4 [...T4(4)|f(12)]
+                    script_lines.push(Fq2::roll(6));
+                    script_lines.push(Fq2::roll(6));
+                    script_lines.push(Fq2::drop());
+                    script_lines.push(Fq2::drop());
+
                     script_lines.push(Fq12::fromaltstack());
                     // [beta_12(2), beta_13(2), beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), c(12), c_inv(12), wi(12), T4(4), f(12)]
                 }
@@ -887,9 +918,24 @@ impl Pairing {
                         if ark_bn254::Config::ATE_LOOP_COUNT[i - 1] == -1 {
                             script_lines.push(Fq2::neg(0));
                         }
+                        // -- push c3,c4 to stack 
+                        script_lines.push(fq2_push_not_montgomery(line_coeffs[num_lines - (i + 2)][j][1].1)); 
+                        script_lines.push(fq2_push_not_montgomery(line_coeffs[num_lines - (i + 2)][j][1].2)); 
+                        // -- [...T4(4),Q4(4),c3(2),c4(2)|f(12)]
+                        // -- move t4,q4 to stack top 
+                        script_lines.push(Fq2::roll(10));
+                        script_lines.push(Fq2::roll(10));
+                        script_lines.push(Fq2::roll(10));
+                        script_lines.push(Fq2::roll(10));
+                        // -- [...c3(2),c4(2),T4(4),Q4(4),|f(12)]
                         script_lines.push(scripts_iter.next().unwrap()); // check_chord_line(line_coeffs[num_lines - (i + 2)][j][1].1, line_coeffs[num_lines - (i + 2)][j][1].2)
                                                                          // [beta_12(2), beta_13(2), beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), c(12), c_inv(12), wi(12), T4(4) | f(12)]
 
+                        //  -- [...T4(4),c3(2),c4(2)|f(12)]
+                        //  -- move c3 c4 to altstack 
+                        script_lines.push(Fq2::toaltstack());
+                        script_lines.push(Fq2::toaltstack());
+                        // -- [...T4(4)|c3(2),c4(2),f(12)]
                         // update T4
                         // drop T4.y, leave T4.x
                         script_lines.push(Fq2::drop());
@@ -897,8 +943,24 @@ impl Pairing {
                         // copy Q4.x
                         script_lines.push(Fq2::copy(4 + 36));
                         // [beta_12(2), beta_13(2), beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), c(12), c_inv(12), wi(12), T4.x(2), Q4.x(2) | f(12)]
+                        
+                        // -- move c3,c4 to stack 
+                        script_lines.push(Fq2::fromaltstack());
+                        script_lines.push(Fq2::fromaltstack());
+                        // -- [...T4.x(2), Q4.x(2),c3(2),c4(2) | f(12)]
+                        // -- move t4.x,q4.x to stack top 
+                        script_lines.push(Fq2::roll(6));
+                        script_lines.push(Fq2::roll(6));
+                        // -- [...,c3(2),c4(2),T4.x(2), Q4.x(2) | f(12)]
                         script_lines.push(scripts_iter.next().unwrap()); // affine_add_line(line_coeffs[num_lines - (i + 2)][j][1].1, line_coeffs[num_lines - (i + 2)][j][1].2)
                                                                          // [beta_12(2), beta_13(2), beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), c(12), c_inv(12), wi(12), T4(4) | f(12)]
+                        // -- [... c3(2),c4(2),T4(4)|f(12)]
+                        // -- drop c3,c4 [... T4(4)|f(12)]
+                        script_lines.push(Fq2::roll(6));
+                        script_lines.push(Fq2::roll(6));
+                        script_lines.push(Fq2::drop());
+                        script_lines.push(Fq2::drop());
+
                         script_lines.push(Fq12::fromaltstack());
                         // [beta_12(2), beta_13(2), beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), c(12), c_inv(12), wi(12), T4(4), f(12)]
                     }
@@ -977,9 +1039,25 @@ impl Pairing {
                 script_lines.push(Fq2::copy(6));
                 script_lines.push(Fq2::copy(6));
                 // [beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), T4(4), phi(Q4)(4), T4(4), phi(Q4)(4) | f(12)]
+                
+                // -- [...T4(4),Q4(4), T4(4),Q4(4)|f(12)]
+                // -- push c3,c4 to stack      
+                script_lines.push(fq2_push_not_montgomery(line_coeffs[num_lines - 2][j][0].1)); 
+                script_lines.push(fq2_push_not_montgomery(line_coeffs[num_lines - 2][j][0].2)); 
+                // -- [... T4(4),Q4(4),T4(4),Q4(4),c3(2),c4(2)|f(12)]
+                // -- move T4,Q4 to stack top  
+                script_lines.push(Fq2::roll(10));
+                script_lines.push(Fq2::roll(10));
+                script_lines.push(Fq2::roll(10));
+                script_lines.push(Fq2::roll(10));
+                // -- [... T4(4),Q4(4),c3(2),c4(2),T4(4),Q4(4),|f(12)]
                 script_lines.push(scripts_iter.next().unwrap()); // check_chord_line(line_coeffs[num_lines - 2][j][0].1, line_coeffs[num_lines - 2][j][0].2)
                                                                  // [beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), T4(4), phi(Q4)(4) | f(12)]
-
+                // -- [... T4(4),Q4(4),c3(2),c4(2)|f(12)]
+                // -- move c3,c4 to altstack 
+                script_lines.push(Fq2::toaltstack());
+                script_lines.push(Fq2::toaltstack());
+                // -- [... T4(4),Q4(4)|,c3(2),c4(2),f(12)]
                 // update T4
                 script_lines.push(Fq2::drop());
                 // [beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), T4(4), phi(Q4).x(2) | f(12)]
@@ -989,8 +1067,23 @@ impl Pairing {
                 // [beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), T4.x(2) | phi(Q4).x(2), f(12)]
                 script_lines.push(Fq2::fromaltstack());
                 // [beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), T4.x(2), phi(Q4).x(2) | f(12)]
+                // -- move c3,c4 to stack          
+                script_lines.push(Fq2::fromaltstack());
+                script_lines.push(Fq2::fromaltstack());
+                // -- [... T4.x(2), phi(Q4).x(2) ,c3(2),c4(2)|f(12)]
+                // -- move T4.x Q4.x to stack top  
+                script_lines.push(Fq2::roll(6)); //  [... phi(Q4).x(2) ,c3(2),c4(2),T4.x(2), |f(12)]
+                script_lines.push(Fq2::roll(6));
+                // -- [... ,c3(2),c4(2), T4.x(2), phi(Q4).x(2) |f(12)]
                 script_lines.push(scripts_iter.next().unwrap()); // affine_add_line(line_coeffs[num_lines - 2][j][0].1, line_coeffs[num_lines - 2][j][0].2)
                                                                  // [beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), T4(4) | f(12)]
+                // -- [...c3(2),c4(2),T4(4)|f(12)]
+                // -- drop c3,c4 
+                script_lines.push(Fq2::roll(6));
+                script_lines.push(Fq2::roll(6));
+                script_lines.push(Fq2::drop());
+                script_lines.push(Fq2::drop());
+                // -- [...,T4(4)|f(12)]
                 script_lines.push(Fq12::fromaltstack());
                 // [beta_22(2), P1(2), P2(2), P3(2), P4(2), Q4(4), T4(4), f(12)]
             }
@@ -1020,9 +1113,24 @@ impl Pairing {
                 // phi(Q4)^2 = (Q4.x', Qy)
                 // [T4(4), phi(Q4)^2(4) | f(12)]
 
+                // -- push c3,c4 to stack    
+                script_lines.push(fq2_push_not_montgomery(line_coeffs[num_lines - 1][j][0].1)); 
+                script_lines.push(fq2_push_not_montgomery(line_coeffs[num_lines - 1][j][0].2)); 
+                // [T4.x(2),T4.y(2),Q4.x(2),Q4.y(2),c3(2),c4(2)|f(12)]
+                // -- move T4,Q4 to stack top 
+                script_lines.push(Fq2::roll(10));// [T4.y(2),Q4.x(2),Q4.y(2),c3(2),c4(2),T4.x(2),|f(12)]
+                script_lines.push(Fq2::roll(10));// [Q4.x(2),Q4.y(2),c3(2),c4(2),T4.x(2),T4.y(2),|f(12)]
+                script_lines.push(Fq2::roll(10));// [Q4.y(2),c3(2),c4(2),T4.x(2),T4.y(2),Q4.x(2),|f(12)]
+                script_lines.push(Fq2::roll(10));// [c3(2),c4(2),T4.x(2),T4.y(2),Q4.x(2),Q4.y(2),|f(12)]
+                // -- [c3(2),c4(2),T4(4),Q4.x(2),Q4.y(2)|f(12)]
                 // check whether the chord line through T4 and phi(Q4)^2
                 script_lines.push(scripts_iter.next().unwrap()); // check_chord_line(line_coeffs[num_lines - 1][j][0].1, line_coeffs[num_lines - 1][j][0].2)
                                                                  // [ | f(12)]
+                // -- [c3(2),c4(2)|f(12)]
+                // -- drop c3,c4  
+                script_lines.push(Fq2::drop());//[c3(2)|f(12)]
+                script_lines.push(Fq2::drop());//[|f(12)]
+                // -- [|f(12)]                                               
                 script_lines.push(Fq12::fromaltstack());
                 // [f(12)]
             }
@@ -1380,7 +1488,7 @@ mod test {
 
             { quad_miller_loop_affine_script }
 
-            { fq12_push_not_montgomery(hint) }
+            { fq12_push_not_montgomery(ark_bn254::Fq12::ONE) }
 
             { Fq12::equalverify() }
 
diff --git a/bitvm/src/bn254/utils.rs b/bitvm/src/bn254/utils.rs
index 9cdbedb82..ed92268f5 100644
--- a/bitvm/src/bn254/utils.rs
+++ b/bitvm/src/bn254/utils.rs
@@ -256,25 +256,26 @@ pub fn hinted_ell_by_constant_affine_and_sparse_mul(
     c2.mul_assign_by_fp(&y);
     let (hinted_script5, hint5) = Fq12::hinted_mul_by_34(f, c1, c2);
 
-    let script_lines: Vec<Script> = vec![
-        // [slope, bias, f,  x', y']
-        {Fq2::roll(16)}, {Fq2::roll(16)},
-        // [f, x', y', slope, bias]
-        {Fq2::roll(4)},
-        // [f, slope, bias, x', y']
-        hinted_script_ell,
-        // [f, c1', c2']
-        // compute the new f with c1'(c3) and c2'(c4), where c1 is trival value 1
-        hinted_script5,
-        // [f]
-    ];
-
-    let mut script = script! {};
-    for script_line in script_lines {
-        script = script.push_script(script_line.compile());
-    }
-    hints.extend(hint_ell);
-    hints.extend(hint5);
+    let hinted_script_constant = script! {
+        for _ in 0..4 {
+            for _ in 0..Fq::N_LIMBS {
+                OP_DEPTH OP_1SUB OP_ROLL 
+            }  
+        }
+     };
+    let script = script! {
+        {hinted_script_constant}
+         // // [slope, bias, f,  x', y']
+         // {Fq2::roll(16)}, {Fq2::roll(16)},
+         // [f, x', y', slope, bias]
+         {Fq2::roll(4)}
+         // [f, slope, bias, x', y']
+         {hinted_script_ell}
+         // [f, c1', c2']
+         // compute the new f with c1'(c3) and c2'(c4), where c1 is trival value 1
+         {hinted_script5}
+         // [f]
+    };
 
     hints.extend_from_slice(&vec![
         Hint::Fq(constant.1.c0),
@@ -283,6 +284,10 @@ pub fn hinted_ell_by_constant_affine_and_sparse_mul(
         Hint::Fq(constant.2.c1),
     ]);
 
+    hints.extend(hint_ell);
+    hints.extend(hint5);
+
+
     (script, hints)
 }
 
@@ -530,7 +535,6 @@ pub fn hinted_from_eval_point(p: ark_bn254::G1Affine) -> (Script, Vec<Hint>) {
     (script, hints)
 }
 
-
 /// input of stack:
 ///      p.x, p.y (affine space)
 /// output on stack:
@@ -635,61 +639,57 @@ pub fn affine_add_line(c3: ark_bn254::Fq2, c4: ark_bn254::Fq2) -> Script {
     }
 }
 
-
-pub fn hinted_affine_add_line(tx: ark_bn254::Fq2, qx: ark_bn254::Fq2, c3: ark_bn254::Fq2, c4: ark_bn254::Fq2) -> (Script, Vec<Hint>) {
+pub fn hinted_affine_add_line(
+    tx: ark_bn254::Fq2,
+    qx: ark_bn254::Fq2,
+    c3: ark_bn254::Fq2,
+    c4: ark_bn254::Fq2,
+) -> (Script, Vec<Hint>) {
     let mut hints = Vec::new();
-    let (hsc, hts) = Fq2::hinted_square(c3);
-    let (hinted_script1, hint1) = Fq2::hinted_mul(4, c3, 0, c3.square()-tx-qx);
-
-    let script_lines = vec! [
-        // [alpha, bias, tx, qx]
-        Fq2::toaltstack(),
-        Fq2::toaltstack(),
-        Fq2::roll(2),
-        Fq2::fromaltstack(),
-        Fq2::fromaltstack(),
-        // [bias, alpha, tx, qx]
+    let (hinted_script0, hint0) = Fq2::hinted_square(c3);
+    let (hinted_script1, hint1) = Fq2::hinted_mul(4, c3, 0, c3.square() - tx - qx);
 
-        // [T.x, Q.x]
+    let script_lines = vec![
+        // [c3, c4, T.x, Q.x]
         Fq2::neg(0),
-        // [T.x, -Q.x]
+        // [c3, c4,T.x, -Q.x]
         Fq2::roll(2),
-        // [-Q.x, T.x]
+        // [c3, c4,-Q.x, T.x]
         Fq2::neg(0),
-        // [-T.x - Q.x]
+        // [c3, c4, -Q.x. -T.x]
         Fq2::add(2, 0),
-        // [-T.x - Q.x]
-        Fq2::roll(2),
+        // [c3, c4, -T.x - Q.x]
+        Fq2::copy(4), // fq2_push_not_montgomery(c3),
+        // [c3, c4, -T.x - Q.x, alpha]
         Fq2::copy(0),
-        hsc,
-        // [-T.x - Q.x, alpha, alpha^2]
+        hinted_script0, // fq2_push_not_montgomery(c3.square()),
+        // [c3, c4, -T.x - Q.x, alpha, alpha^2]
         // calculate x' = alpha^2 - T.x - Q.x
         Fq2::add(4, 0),
-        // [alpha, x']
+        // [c3, c4, alpha, x']
         Fq2::copy(0),
-        // [alpha, x', x']
+        // [c3, c4, alpha, x', x']
         hinted_script1,
-        // [x', alpha * x']
+        // [c3, c4, x', alpha * x']
         Fq2::neg(0),
-        // [x', -alpha * x']
-        // fq2_push_not_montgomery(c4),
+        // [c3, c4, x', -alpha * x']
+        Fq2::copy(4),// fq2_push_not_montgomery(c4),
         // [x', -alpha * x', -bias]
         // compute y' = -bias - alpha * x'
-        Fq2::add(4, 0),
-        // [x', y']
+        Fq2::add(2, 0),
+        // [c3, c4, x', y']
     ];
 
-    let mut script = script!{};
+    let mut script = script! {};
     for script_line in script_lines {
         script = script.push_script(script_line.compile());
     }
-    hints.extend(hts);
+    hints.extend(hint0);
     hints.extend(hint1);
 
     (script, hints)
 }
 
-
 /// double a point T:
 ///     x' = alpha^2 - 2 * T.x
 ///     y' = -bias - alpha* x'
@@ -722,50 +722,47 @@ pub fn affine_double_line(c3: ark_bn254::Fq2, c4: ark_bn254::Fq2) -> Script {
     }
 }
 
-pub fn hinted_affine_double_line(tx: ark_bn254::Fq2, c3: ark_bn254::Fq2, c4: ark_bn254::Fq2) -> (Script, Vec<Hint>) {
+pub fn hinted_affine_double_line(
+    tx: ark_bn254::Fq2,
+    c3: ark_bn254::Fq2,
+    c4: ark_bn254::Fq2,
+) -> (Script, Vec<Hint>) {
     let mut hints = Vec::new();
 
-    let (hsc, hts) = Fq2::hinted_square(c3);
-    let (hinted_script1, hint1) = Fq2::hinted_mul(4, c3, 0, c3.square()-tx-tx);
-
-    let script_lines = vec! [
-        // [alpha, bias, tx]
-        Fq2::toaltstack(),
-        Fq2::roll(2),
-        Fq2::fromaltstack(),
-        // [bias, alpha, tx]
+    let (hinted_script0, hint0) = Fq2::hinted_square(c3);
+    let (hinted_script1, hint1) = Fq2::hinted_mul(4, c3, 0, c3.square() - tx - tx);
 
+    //[c3(2), c4(2), t.x(2)]
+    let script_lines = vec![
         Fq2::double(0),
         Fq2::neg(0),
-        // [alpha, - 2 * T.x]
-        Fq2::roll(2),
+        // [c3(2), c4(2), - 2 * T.x(2)]
+        Fq2::copy(4),// fq2_push_not_montgomery(c3),
         Fq2::copy(0),
-        hsc,
-        // fq2_push_not_montgomery(c3.square()),
-        // [- 2 * T.x, alpha, alpha^2]
+        hinted_script0, // fq2_push_not_montgomery(c3.square()),
+        // [c3(2), c4(2), - 2 * T.x, alpha, alpha^2]
         Fq2::add(4, 0),
         Fq2::copy(0),
-        // [alpha, x', x']
+        // [c3(2), c4(2), alpha, x', x']
         hinted_script1,
         Fq2::neg(0),
-        // [x', -alpha * x']
-
-        Fq2::add(4, 0),
-        // [x', y']
+        // [c3(2), c4(2), x', -alpha * x']
+        Fq2::copy(4),//fq2_push_not_montgomery(c4),
+        // [c3(2), c4(2), x', -alpha * x', c4(2)]
+        Fq2::add(2, 0),
+        // [c3(2), c4(2), x', y']
     ];
 
-    let mut script = script!{};
-
+    let mut script = script! {};
     for script_line in script_lines {
         script = script.push_script(script_line.compile());
     }
-    hints.extend(hts);
+    hints.extend(hint0);
     hints.extend(hint1);
 
     (script, hints)
 }
 
-
 /// check line through one point, that is:
 ///     y - alpha * x - bias = 0
 ///
@@ -810,35 +807,40 @@ pub fn hinted_check_tangent_line(
 ) -> (Script, Vec<Hint>) {
     let mut hints = Vec::new();
 
+    // let (hinted_script1, hint1) = Fq2::hinted_mul_by_constant(t.y.double(), &c3);
     let (hinted_script1, hint1) = Fq2::hinted_mul(2, t.y.double(), 0, c3);
     let (hinted_script2, hint2) = Fq2::hinted_square(t.x);
     let (hinted_script3, hint3) = hinted_check_line_through_point(t.x, c3, c4);
-
-    // [a, b, x, y]
+    
+    // [c3(2),c4(2),t(4) ]
     let script_lines = vec![
         // alpha * (2 * T.y) = 3 * T.x^2
         Fq2::copy(0),
         Fq2::double(0),
-        // [a, b, x, y, 2y]
+        // [c3(2),c4(2),t(4),t.y*2 (2)]
         Fq2::copy(8),
-        // [a, b, x, y, 2y, a]
+        // [c3(2),c4(2),t(4),t.y*2 (2), c3(2)]
         hinted_script1,
-        // [T.x, T.y, alpha * (2 * T.y)]
+        // [c3(2),c4(2), T.x(2), T.y(2), alpha * 2 * T.y (2)]
         Fq2::copy(4),
+        // [c3(2),c4(2), T.x(2), T.y(2), alpha * 2 * T.y (2), T.x(2)]
         hinted_script2,
+        // [c3(2),c4(2), T.x(2), T.y(2), alpha * 2 * T.y (2), T.x^2(2)]
         Fq2::copy(0),
+        // [c3(2),c4(2), T.x(2), T.y(2), alpha * 2 * T.y (2), T.x^2(2), T.x^2(2) ]
         Fq2::double(0),
+        // [c3(2),c4(2), T.x(2), T.y(2), alpha * 2 * T.y (2), T.x^2(2), 2 * T.x^2(2) ]
         Fq2::add(2, 0),
-        // [T.x, T.y, alpha * (2 * T.y), 3 * T.x^2]
+        // [c3(2),c4(2), T.x(2), T.y(2), alpha * 2 * T.y(2), 3 * T.x^2(2)]
         Fq2::neg(0),
         Fq2::add(2, 0),
         Fq2::push_zero(),
         Fq2::equalverify(),
-        // [T.x, T.y]
+        // [c3(2),c4(2), T.x(2), T.y(2)]
 
         // check: T.y - alpha * T.x - bias = 0
         hinted_script3,
-        // []
+        // [c3(2),c4(2)]
     ];
 
     let mut script = script! {};
@@ -852,33 +854,39 @@ pub fn hinted_check_tangent_line(
     (script, hints)
 }
 
-
-
-pub fn hinted_check_line_through_point(x: ark_bn254::Fq2, c3: ark_bn254::Fq2, _c4: ark_bn254::Fq2) -> (Script, Vec<Hint>) {
+pub fn hinted_check_line_through_point(
+    x: ark_bn254::Fq2,
+    c3: ark_bn254::Fq2,
+    c4: ark_bn254::Fq2,
+) -> (Script, Vec<Hint>) {
     let mut hints: Vec<Hint> = Vec::new();
-    
-    let (hinted_script1, hint1) = Fq2::hinted_mul(2, x,0, c3);
+
+    // let (hinted_script1, hint1) = Fq2::hinted_mul_by_constant(x, &c3);
+    let (hinted_script1, hint1) = Fq2::hinted_mul(2, x, 0, c3);
 
     let script_lines = vec![
-        // [alpha, bias, x, y ]
+        // [c3, c4, x, y]
         Fq2::roll(2),
-        // [alpha, bias, y, x ]
-        Fq2::roll(6),
+        // [c3, c4, y, x]
+        Fq2::copy(6),
+        // [c3, c4, y, x,c3]
         hinted_script1,
-        // [bias, y, alpha * x]
+        // [c3, c4, y, alpha * x]
         Fq2::neg(0),
-        // [bias, y, -alpha * x]
+        // [c3, c4, y, -alpha * x]
         Fq2::add(2, 0),
-        // [bias, y - alpha * x]
+        // [c3, c4, y - alpha * x]
+        Fq2::copy(2), // fq2_push_not_montgomery(c4),
+        // [c3, c4, y - alpha * x, -bias]
         Fq2::add(2, 0),
-        // [y - alpha * x - bias]
-
+        // [c3, c4, y - alpha * x - bias]
         Fq2::push_zero(),
-        // [y - alpha * x - bias, 0]
+        // [c3, c4, y - alpha * x - bias, 0]
         Fq2::equalverify(),
+        // [c3, c4]
     ];
 
-    let mut script = script!{};
+    let mut script = script! {};
     for script_line in script_lines {
         script = script.push_script(script_line.compile());
     }
@@ -887,7 +895,6 @@ pub fn hinted_check_line_through_point(x: ark_bn254::Fq2, c3: ark_bn254::Fq2, _c
     (script, hints)
 }
 
-
 /// check whether a tuple coefficient (alpha, -bias) of a tangent line is satisfied with expected point T (affine)
 /// two aspects:
 ///     1. alpha * (2 * T.y) = 3 * T.x^2, make sure the alpha is the right ONE
@@ -955,29 +962,40 @@ pub fn check_chord_line(c3: ark_bn254::Fq2, c4: ark_bn254::Fq2) -> Script {
     }
 }
 
-pub fn hinted_check_chord_line(t: ark_bn254::G2Affine, q: ark_bn254::G2Affine, c3: ark_bn254::Fq2, c4: ark_bn254::Fq2) -> (Script, Vec<Hint>) {
+pub fn hinted_check_chord_line(
+    t: ark_bn254::G2Affine,
+    q: ark_bn254::G2Affine,
+    c3: ark_bn254::Fq2,
+    c4: ark_bn254::Fq2,
+) -> (Script, Vec<Hint>) {
     let mut hints = Vec::new();
 
-    let (script1, hint1) = hinted_check_line_through_point(t.x, c3, c4);
-    let (script2, hint2) = hinted_check_line_through_point(q.x, c3, c4);
+    let (script1, hint1) = hinted_check_line_through_point(q.x, c3, c4);
+    let (script2, hint2) = hinted_check_line_through_point(t.x, c3, c4);
 
-
-    // [a, b, tx, ty, qx, qy]
-    let script_lines = vec![
-        {Fq2::toaltstack()},
-        {Fq2::toaltstack()},
-        {Fq2::copy(6)}, 
-        {Fq2::copy(6)},
-        {Fq2::toaltstack()},
-        {Fq2::toaltstack()},
-        script1, // t
-        {Fq2::fromaltstack()}, 
-        {Fq2::fromaltstack()}, 
-        {Fq2::fromaltstack()}, 
-        {Fq2::fromaltstack()}, 
-        script2, //q
+     
+    //[c3(2),c4(2),t(4),q(4)]
+     let script_lines = vec![
+        Fq2::copy(10),
+        // [c3(2),c4(2),t(4),q(4),c3(2)]
+        Fq2::copy(10),
+        // [c3(2),c4(2),t(4),q(4),c3(2),c4(2)]
+        Fq2::roll(6),
+        Fq2::roll(6),
+        //[c3(2),c4(2),t(4),c3(2),c4(2),q(4)]
+        script1,
+        // // [c3(2),c4(2),t4(4),c3(2),c4(2)]
+        Fq2::roll(6),
+        Fq2::roll(6),
+        // [c3(2),c4(2),c3(2),c4(2),t4(4)]
+        script2,
+        // [c3(2),c4(2),c3(2),c4(2)]
+        Fq2::drop(),
+        Fq2::drop(),
+        // [c3(2),c4(2)]
     ];
-    let mut script = script!{};
+
+    let mut script = script! {};
     for script_line in script_lines {
         script = script.push_script(script_line.compile());
     }
@@ -988,7 +1006,6 @@ pub fn hinted_check_chord_line(t: ark_bn254::G2Affine, q: ark_bn254::G2Affine, c
     (script, hints)
 }
 
-
 // stack data: beta^{2 * (p - 1) / 6}, beta^{3 * (p - 1) / 6}, beta^{2 * (p^2 - 1) / 6}, 1/2, B,
 // P1, P2, P3, P4, Q4, c, c', wi, f, Px, Py, Tx, Ty, Tz, Qx, Qy
 // [..., Fq12, Fq12, Fq12, Fq12, Fq, Fq, (Fq, Fq), (Fq, Fq), (Fq, Fq), (Fq, Fq), (Fq, Fq)]
@@ -1338,17 +1355,12 @@ pub fn double_line() -> Script {
     }
 }
 
-
-
-
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::bn254::{ fq2::Fq2};
-    use ark_bn254::G2Affine;
+    use crate::bn254::fq2::Fq2;
     use ark_ff::AdditiveGroup;
     use ark_std::UniformRand;
-    use bitcoin::opcodes::OP_TRUE;
     use num_traits::One;
     use rand::SeedableRng;
     use rand_chacha::ChaCha20Rng;
@@ -1727,6 +1739,11 @@ mod test {
             { fq2_push_not_montgomery(t.x) }
             { fq2_push_not_montgomery(q.x) }
             { hinted_add_line.clone() }
+            // [c3(2),c4(2),add(4)]
+            { Fq2::roll(6) }
+            { Fq2::roll(6) }
+            { Fq2::drop() }
+            { Fq2::drop() }
             // [x']
             { fq2_push_not_montgomery(y) }
             // [x', y', y]
@@ -1785,6 +1802,7 @@ mod test {
         run(script);
     }
 
+
     #[test]
     fn test_hinted_check_line_through_point() {
         let mut prng = ChaCha20Rng::seed_from_u64(0);
@@ -1810,6 +1828,8 @@ mod test {
             { fq2_push_not_montgomery(t.x) }
             { fq2_push_not_montgomery(t.y) }
             {scr}
+            { Fq2::drop() }
+            { Fq2::drop() }
             OP_TRUE
         };
         assert!(execute_script(script).success);
@@ -1846,6 +1866,11 @@ mod test {
             { fq2_push_not_montgomery(bias_minus) }
             { fq2_push_not_montgomery(t.x) }
             { hinted_double_line }
+            // [c3(2),c4(2),add(4)]
+            { Fq2::roll(6) }
+            { Fq2::roll(6) }
+            { Fq2::drop() }
+            { Fq2::drop() }
             // [x']
             { fq2_push_not_montgomery(y) }
             // [x', y', y]
@@ -1913,6 +1938,8 @@ mod test {
             { fq2_push_not_montgomery(t.x) }
             { fq2_push_not_montgomery(t.y) }
             { hinted_check_line.clone() }
+            { Fq2::drop() }
+            { Fq2::drop() }
             OP_TRUE
         };
         let exec_result = execute_script(script);
@@ -1967,6 +1994,8 @@ mod test {
             { fq2_push_not_montgomery(q.x) }
             { fq2_push_not_montgomery(q.y) }
             { hinted_check_line.clone() }
+            { Fq2::drop() }
+            { Fq2::drop() }
             OP_TRUE
         };
         let exec_result = execute_script(script);
@@ -1977,5 +2006,4 @@ mod test {
             exec_result.stats.max_nb_stack_items
         );
     }
-
 }
diff --git a/bitvm/src/chunker/chunk_accumulator.rs b/bitvm/src/chunker/chunk_accumulator.rs
index 715c3ad30..946ee6aec 100644
--- a/bitvm/src/chunker/chunk_accumulator.rs
+++ b/bitvm/src/chunker/chunk_accumulator.rs
@@ -10,6 +10,7 @@ use super::segment::*;
 use crate::bn254::ell_coeffs::EllCoeff;
 use crate::bn254::ell_coeffs::G2Prepared;
 use crate::bn254::fq12::Fq12;
+use crate::bn254::fq2::Fq2;
 use crate::bn254::utils::*;
 use crate::treepp::*;
 
@@ -20,6 +21,7 @@ pub fn chunk_accumulator<T: BCAssigner>(
     assigner: &mut T,
     im_var_p: Vec<Fq2Type>,
     constants: Vec<G2Prepared>,
+    line_coeffs_4: &Vec<Vec<Fq6Type>>,
     c: ark_bn254::Fq12,
     c_inv: ark_bn254::Fq12,
     wi: ark_bn254::Fq12,
@@ -29,8 +31,8 @@ pub fn chunk_accumulator<T: BCAssigner>(
 
     assert_eq!(constants.len(), 4);
     let num_line_groups = constants.len();
+    let line_coeffs: Vec<Vec<Vec<(ark_bn254::Fq2, ark_bn254::Fq2, ark_bn254::Fq2)>>> = collect_line_coeffs(constants);
 
-    let line_coeffs = collect_line_coeffs(constants);
     let num_lines = line_coeffs.len();
 
     let mut f = c_inv;
@@ -100,7 +102,13 @@ pub fn chunk_accumulator<T: BCAssigner>(
             c2new.mul_assign_by_fp(&(p.y.inverse().unwrap()));
             fx.mul_by_034(&coeffs.0, &c1new, &c2new);
 
-            let (s, r) = make_chunk_ell(
+            let coeffs_4 = if j == num_line_groups-1 {
+                Some(line_coeffs_4[num_lines - (i + 2)][0].clone())
+            } else {
+                None
+            };
+
+            let (s, r) =  make_chunk_ell(
                 assigner,
                 format!("F_{}_mul_c_1p{}", i, j),
                 param_f,
@@ -109,7 +117,9 @@ pub fn chunk_accumulator<T: BCAssigner>(
                 -p.x / p.y,
                 p.y.inverse().unwrap(),
                 coeffs,
+                coeffs_4,
             );
+            
             segments.extend(s);
             param_f = r;
             f = fx;
@@ -129,6 +139,11 @@ pub fn chunk_accumulator<T: BCAssigner>(
                 c2new.mul_assign_by_fp(&(p.y.inverse().unwrap()));
                 fx.mul_by_034(&coeffs.0, &c1new, &c2new);
 
+                let coeffs_4 = if j == num_line_groups-1 {
+                    Some(line_coeffs_4[num_lines - (i + 2)][1].clone())
+                } else {
+                    None
+                };
                 let (s, r) = make_chunk_ell(
                     assigner,
                     format!("F_{}_mul_c_2p{}", i, j),
@@ -138,7 +153,9 @@ pub fn chunk_accumulator<T: BCAssigner>(
                     -p.x / p.y,
                     p.y.inverse().unwrap(),
                     coeffs,
+                    coeffs_4,
                 );
+
                 segments.extend(s);
                 param_f = r;
                 f = fx;
@@ -254,8 +271,14 @@ pub fn chunk_accumulator<T: BCAssigner>(
         c2new.mul_assign_by_fp(&(p.y.inverse().unwrap()));
         fx.mul_by_034(&coeffs.0, &c1new, &c2new);
 
+        let coeffs_4 = if j == num_line_groups-1 {
+            Some(line_coeffs_4[num_lines - 2][0].clone())
+        } else {
+            None
+        };
+
         let (s, r) = make_chunk_ell(
-            assigner,
+                assigner,
             format!("F_final_1p{}", j),
             param_f,
             im_var_p[j].clone(),
@@ -263,7 +286,8 @@ pub fn chunk_accumulator<T: BCAssigner>(
             -p.x / p.y,
             p.y.inverse().unwrap(),
             coeffs,
-        );
+                coeffs_4,
+            );
 
         segments.extend(s);
         param_f = r;
@@ -281,8 +305,14 @@ pub fn chunk_accumulator<T: BCAssigner>(
         c2new.mul_assign_by_fp(&(p.y.inverse().unwrap()));
         fx.mul_by_034(&coeffs.0, &c1new, &c2new);
 
+        let coeffs_4 = if j == num_line_groups-1 {
+            Some(line_coeffs_4[num_lines - 1][0].clone())
+        } else {
+            None
+        };
+
         let (s, r) = make_chunk_ell(
-            assigner,
+                assigner,
             format!("F_final_2p{}", j),
             param_f,
             im_var_p[j].clone(),
@@ -290,7 +320,8 @@ pub fn chunk_accumulator<T: BCAssigner>(
             -p.x / p.y,
             p.y.inverse().unwrap(),
             coeffs,
-        );
+                coeffs_4,
+            );
 
         segments.extend(s);
         param_f = r;
@@ -301,6 +332,24 @@ pub fn chunk_accumulator<T: BCAssigner>(
     (segments, param_f, f)
 }
 
+#[allow(clippy::too_many_arguments)]
+pub fn make_chunk_mul<T: BCAssigner>(
+    assigner: &mut T,
+    fn_name: String,
+    param_a: Fq12Type,
+    param_b: Fq12Type,
+    a: ark_bn254::Fq12,
+    b: ark_bn254::Fq12,
+) -> (Vec<Segment>, Fq12Type) {
+    let mut segments = vec![];
+
+    let (segments_mul, c) = fq12_mul_wrapper(assigner, &fn_name, param_a, param_b, a, b);
+    segments.extend(segments_mul);
+
+    (segments, c)
+}
+
+#[allow(clippy::too_many_arguments)]
 pub fn make_chunk_square<T: BCAssigner>(
     assigner: &mut T,
     fn_name: String,
@@ -322,22 +371,6 @@ pub fn make_chunk_square<T: BCAssigner>(
     (segments, c)
 }
 
-pub fn make_chunk_mul<T: BCAssigner>(
-    assigner: &mut T,
-    fn_name: String,
-    param_a: Fq12Type,
-    param_b: Fq12Type,
-    a: ark_bn254::Fq12,
-    b: ark_bn254::Fq12,
-) -> (Vec<Segment>, Fq12Type) {
-    let mut segments = vec![];
-
-    let (segments_mul, c) = fq12_mul_wrapper(assigner, &fn_name, param_a, param_b, a, b);
-    segments.extend(segments_mul);
-
-    (segments, c)
-}
-
 #[allow(clippy::too_many_arguments)]
 pub fn make_chunk_ell<T: BCAssigner>(
     assigner: &mut T,
@@ -348,15 +381,15 @@ pub fn make_chunk_ell<T: BCAssigner>(
     x: ark_bn254::Fq,
     y: ark_bn254::Fq,
     constant: &EllCoeff,
+    constant_4:Option<Fq6Type>,
 ) -> (Vec<Segment>, Fq12Type) {
     let mut segments = vec![];
-
-    let (segments_mul, c) = chunk_evaluate_line(assigner, &fn_name, pf, pxy, f, x, y, constant);
+    let (segments_mul, c) = chunk_evaluate_line(assigner, &fn_name, pf, pxy, f, x, y, constant,constant_4);
     segments.extend(segments_mul);
-
     (segments, c)
 }
 
+
 pub fn make_chunk_frobenius_map<T: BCAssigner>(
     assigner: &mut T,
     fn_name: String,
diff --git a/bitvm/src/chunker/chunk_evaluate_line.rs b/bitvm/src/chunker/chunk_evaluate_line.rs
index c320ef2e9..fb2b950b0 100644
--- a/bitvm/src/chunker/chunk_evaluate_line.rs
+++ b/bitvm/src/chunker/chunk_evaluate_line.rs
@@ -7,6 +7,7 @@ use crate::bn254::{ell_coeffs::EllCoeff, fp254impl::Fp254Impl, fq::Fq, fq12::Fq1
 use crate::treepp::*;
 use ark_ff::{AdditiveGroup, Field};
 
+#[allow(clippy::too_many_arguments)]
 pub fn chunk_evaluate_line_wrapper<T: BCAssigner>(
     assigner: &mut T,
     prefix: &str,
@@ -20,7 +21,7 @@ pub fn chunk_evaluate_line_wrapper<T: BCAssigner>(
     let mut pxy = Fq2Type::new(assigner, &format!("{}{}", prefix, "xy"));
     pxy.fill_with_data(Fq2Data(ark_bn254::Fq2::new(x, y)));
 
-    chunk_evaluate_line(assigner, prefix, pf, pxy, f, x, y, constant)
+    chunk_evaluate_line(assigner, prefix, pf, pxy, f, x, y, constant,None)
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -33,19 +34,73 @@ pub fn chunk_evaluate_line<T: BCAssigner>(
     x: ark_bn254::Fq,
     y: ark_bn254::Fq,
     constant: &EllCoeff,
+    constant_4:Option<Fq6Type>,
 ) -> (Vec<Segment>, Fq12Type) {
     assert_eq!(constant.0, ark_bn254::Fq2::ONE);
 
-    let (hinted_script1, hint1) = Fq::hinted_mul_by_constant_stable(x, &constant.1.c0);
-    let (hinted_script2, hint2) = Fq::hinted_mul_by_constant_stable(x, &constant.1.c1);
-    let (hinted_script3, hint3) = Fq::hinted_mul_by_constant_stable(y, &constant.2.c0);
-    let (hinted_script4, hint4) = Fq::hinted_mul_by_constant_stable(y, &constant.2.c1);
+    let (hinted_script1, hint1) = if constant_4.is_some() {
+        Fq::hinted_mul(1,x,0, constant.1.c0) 
+    } else {
+        Fq::hinted_mul_by_constant(x, &constant.1.c0)
+    };
+    let (hinted_script2, hint2) =  if constant_4.is_some() {
+        Fq::hinted_mul(1,x,0, constant.1.c1)  
+    } else {
+        Fq::hinted_mul_by_constant(x, &constant.1.c1)
+    };
+    let (hinted_script3, hint3) =  if constant_4.is_some() {
+        Fq::hinted_mul(1,y,0, constant.2.c0) 
+    } else {
+        Fq::hinted_mul_by_constant(y, &constant.2.c0)
+    };
+    let (hinted_script4, hint4) =  if constant_4.is_some() {
+        Fq::hinted_mul(1,y,0, constant.2.c1) 
+    } else {
+        Fq::hinted_mul_by_constant(y, &constant.2.c1)
+    };
+
     let mut c1 = constant.1;
     c1.mul_assign_by_fp(&x);
     let mut c2 = constant.2;
     c2.mul_assign_by_fp(&y);
 
-    let script_lines_0 = vec![
+    let script_lines_0 = if constant_4.is_some() {
+        vec![
+            // [c0.0,c0.1, c1.0, c1.1, c2.0, c2.1, x, y]
+            Fq::roll(7),
+            // [c0.1, c1.0, c1.1, c2.0, c2.1, x, y,c0.0]
+            Fq::roll(7),
+            // [ c1.0, c1.1, c2.0, c2.1, x, y,c0.0,c0.1]
+            Fq::drop(),
+            Fq::drop(),
+            // [c1.0, c1.1, c2.0, c2.1, x, y]
+            Fq::copy(1),
+            // [c1.0, c1.1, c2.0, c2.1, x, y, x]
+            Fq::roll(6),
+            // [c1.1, c2.0, c2.1, x, y, x, c1.0]
+            hinted_script1,
+            // [c1.1, c2.0, c2.1, x, y, x*c1.0]
+            Fq::roll(2),
+            // [c1.1, c2.0, c2.1, y, x*c1.0, x]
+            Fq::roll(5),
+            // [ c2.0, c2.1, y, x*c1.0, x, c1.1]
+            hinted_script2,
+            // [ c2.0, c2.1, y, x*c1.0, x*c1.1]
+            Fq::copy(2),
+            // [ c2.0, c2.1, y, x*c1.0, x*c1.1, y]
+            Fq::roll(5),
+            // [ c2.1, y, x*c1.0, x*c1.1, y, c2.0]
+            hinted_script3,
+            // [ c2.1, y, x*c1.0, x*c1.1, y*c2.0]
+            Fq::roll(3),
+            // [ c2.1, x*c1.0, x*c1.1, y*c2.0, y]
+            Fq::roll(4),
+            // [ x*c1.0, x*c1.1, y*c2.0, y, c2.1]
+            hinted_script4,
+            // [ x*c1.0, x*c1.1, y*c2.0, y*c2.1]
+        ]
+    } else {
+        vec![
         // [x', y']
         // update c1, c1' = x' * c1
         Fq::copy(1),
@@ -65,7 +120,9 @@ pub fn chunk_evaluate_line<T: BCAssigner>(
         // [x' * c1, y' * c2.0, y' * c2.1]
         // [x' * c1, y' * c2]
         // [c1', c2']
-    ];
+        ]
+    };
+
     let mut script_0 = script! {};
     for script_line_0 in script_lines_0 {
         script_0 = script_0.push_script(script_line_0.compile());
@@ -75,19 +132,21 @@ pub fn chunk_evaluate_line<T: BCAssigner>(
     hints_0.extend(hint2);
     hints_0.extend(hint3);
     hints_0.extend(hint4);
-    //
 
     let mut tr0 = Fq6Type::new(assigner, &format!("{}{}", prefix, "c0"));
     tr0.fill_with_data(Fq6Data(ark_bn254::Fq6::new(c1, c2, ark_bn254::Fq2::ZERO)));
 
-    let segment0 = Segment::new_with_name(
+    let mut segment0 = Segment::new_with_name(
         format!("{}seg1", prefix),
         script! {
             {script_0}
             {Fq2::push_zero()}
         },
-    )
-    .add_parameter(&pxy)
+    );
+    if constant_4.is_some() {
+        segment0 = segment0.add_parameter(constant_4.as_ref().unwrap())
+    }
+    segment0 = segment0.add_parameter(&pxy)
     .add_result(&tr0)
     .add_hint(hints_0);
 
@@ -117,6 +176,8 @@ pub fn chunk_evaluate_line<T: BCAssigner>(
     (vec![segment0, segment1], tc)
 }
 
+
+
 #[cfg(test)]
 mod test {
     use super::chunk_evaluate_line_wrapper;
diff --git a/bitvm/src/chunker/chunk_groth16_verifier.rs b/bitvm/src/chunker/chunk_groth16_verifier.rs
index c22d58eed..80bb668d2 100644
--- a/bitvm/src/chunker/chunk_groth16_verifier.rs
+++ b/bitvm/src/chunker/chunk_groth16_verifier.rs
@@ -1,8 +1,9 @@
 use crate::bn254::ell_coeffs::G2Prepared;
+use crate::bn254::utils::collect_line_coeffs;
 use crate::chunker::chunk_g1_points::g1_points;
 use crate::chunker::chunk_msm::chunk_hinted_msm_with_constant_bases_affine;
 use crate::chunker::chunk_non_fixed_point::chunk_q4;
-use crate::chunker::elements::{ElementTrait, FrType, G2PointType};
+use crate::chunker::elements::{ElementTrait, DataType::Fq6Data,Fq6Type, FrType, G2PointType};
 use crate::chunker::{chunk_accumulator, chunk_hinted_accumulator};
 use crate::groth16::constants::{LAMBDA, P_POW3};
 use crate::groth16::offchain_checker::compute_c_wi;
@@ -92,10 +93,30 @@ pub fn groth16_verify_to_segments<T: BCAssigner>(
     let (segment, tp_lst) = g1_points(assigner, p1_type, p1, proof, vk);
     segments.extend(segment);
 
-    let (segment, fs, _) = chunk_accumulator::chunk_accumulator(
+    let constants = q_prepared.to_vec();
+    assert_eq!(constants.len(), 4);
+    let num_line_groups = constants.len();
+    let mut line_coeffs_4: Vec<Vec<Fq6Type>> = vec![];
+    let line_coeffs = collect_line_coeffs(constants);
+    for i in 0..line_coeffs.len() {
+        let line_coeff = &line_coeffs[i];
+        assert_eq!(line_coeff.len(), num_line_groups);
+        let mut line_coeff_4 = vec![];
+        for j in 0..line_coeff[num_line_groups-1].len() {
+            let coeff = &line_coeff[num_line_groups-1][j];
+            let mut fq6 = Fq6Type::new(assigner, &format!("line_coeffs_4_{i}{j}"));
+            let data = ark_bn254::Fq6::new(coeff.0,coeff.1,coeff.2);
+            fq6.fill_with_data(Fq6Data(data));
+            line_coeff_4.push(fq6);
+        }
+        line_coeffs_4.push(line_coeff_4);
+    }
+
+    let (segment, fs, f) = chunk_accumulator::chunk_accumulator(
         assigner,
         tp_lst,
         q_prepared.to_vec(),
+        &line_coeffs_4,
         c,
         c_inv,
         wi,
@@ -108,7 +129,7 @@ pub fn groth16_verify_to_segments<T: BCAssigner>(
 
     let mut q4_input = G2PointType::new(assigner, "q4");
     q4_input.fill_with_data(crate::chunker::elements::DataType::G2PointData(q4));
-    let segment = chunk_q4(q_prepared.to_vec(), q4, q4_input, assigner);
+    let segment = chunk_q4(q_prepared.to_vec(),&line_coeffs_4, q4, q4_input, assigner);
 
     segments.extend(segment);
 
diff --git a/bitvm/src/chunker/chunk_hinted_accumulator.rs b/bitvm/src/chunker/chunk_hinted_accumulator.rs
index 6747d1ca1..b6e78c849 100644
--- a/bitvm/src/chunker/chunk_hinted_accumulator.rs
+++ b/bitvm/src/chunker/chunk_hinted_accumulator.rs
@@ -13,7 +13,7 @@ pub fn verify_accumulator(pa: Fq12Type) -> Vec<Segment> {
     };
 
     let mut segments = vec![];
-    let segment = Segment::new_with_name("verify_f".to_string(), script)
+    let segment = Segment::new_with_name(format!("{}", "verify_f"), script)
         .add_parameter(&pa)
         .mark_final();
 
@@ -26,11 +26,13 @@ mod test {
     use super::*;
     use crate::bn254::ell_coeffs::G2Prepared;
 
+    use crate::bn254::utils::collect_line_coeffs;
     use crate::chunker::assigner::*;
     use crate::chunker::chunk_accumulator::*;
     use crate::chunker::chunk_g1_points::*;
     use crate::chunker::elements::DataType::G1PointData;
-    use crate::chunker::elements::{DataType::Fq12Data, ElementTrait, G1PointType};
+    use crate::chunker::elements::Fq6Type;
+    use crate::chunker::elements::{DataType::Fq6Data,DataType::Fq12Data, ElementTrait, G1PointType};
     use crate::execute_script_with_inputs;
     use crate::groth16::constants::{LAMBDA, P_POW3};
     use crate::groth16::offchain_checker::compute_c_wi;
@@ -291,8 +293,29 @@ mod test {
         let (_, tp_lst) = g1_points(&mut assigner, g1p, g1a, &proof, &vk);
 
         let (constants, c, c_inv, wi, p_lst, _) = generate_f_arg(&vec![c], &proof, &vk);
+        
+
+        let constants = constants.clone();
+        assert_eq!(constants.len(), 4);
+        let num_line_groups = constants.len();
+        let mut line_coeffs_4: Vec<Vec<Fq6Type>> = vec![];
+        let line_coeffs = collect_line_coeffs(constants.clone());
+        for i in 0..line_coeffs.len() {
+            let line_coeff = &line_coeffs[i];
+            assert_eq!(line_coeff.len(), num_line_groups);
+            let mut line_coeff_4 = vec![];
+            for j in 0..line_coeff[num_line_groups-1].len() {
+                let coeff = &line_coeff[num_line_groups-1][j];
+                let mut fq6 = Fq6Type::new(&mut assigner, &format!("line_coeffs_4_{i}{j}"));
+                let data = ark_bn254::Fq6::new(coeff.0,coeff.1,coeff.2);
+                fq6.fill_with_data(Fq6Data(data));
+                line_coeff_4.push(fq6);
+            }
+            line_coeffs_4.push(line_coeff_4);
+        }
+        
         let (segments, fs, f) =
-            chunk_accumulator(&mut assigner, tp_lst, constants, c, c_inv, wi, p_lst);
+            chunk_accumulator(&mut assigner, tp_lst, constants, &line_coeffs_4,c, c_inv, wi, p_lst);
         println!("tf: {} \n f: {}", tf, f);
         println!("tc: {:?} \n fs: {:?}", tc, fs);
 
diff --git a/bitvm/src/chunker/chunk_non_fixed_point.rs b/bitvm/src/chunker/chunk_non_fixed_point.rs
index 6b67d65c0..1fa2712fd 100644
--- a/bitvm/src/chunker/chunk_non_fixed_point.rs
+++ b/bitvm/src/chunker/chunk_non_fixed_point.rs
@@ -13,11 +13,12 @@ use num_traits::One;
 use std::{ops::Neg, str::FromStr};
 
 use super::assigner::BCAssigner;
-use super::elements::G2PointType;
+use super::elements::{Fq6Type, G2PointType};
 use super::segment::Segment;
 
 pub fn chunk_q4<T: BCAssigner>(
     constants: Vec<G2Prepared>,
+    line_coeffs_4: &Vec<Vec<Fq6Type>>,
     q4: ark_bn254::G2Affine,
     q4_input: G2PointType,
     assigner: &mut T,
@@ -56,13 +57,6 @@ pub fn chunk_q4<T: BCAssigner>(
                 let t4x = ark_bn254::G2Affine::new(x, y);
 
                 let mut hints = vec![];
-                hints.extend_from_slice(&vec![
-                    Hint::Fq(line_coeffs[num_lines - (i + 2)][j][0].1.c0), 
-                    Hint::Fq(line_coeffs[num_lines - (i + 2)][j][0].1.c1), 
-                    Hint::Fq(line_coeffs[num_lines - (i + 2)][j][0].2.c0), 
-                    Hint::Fq(line_coeffs[num_lines - (i + 2)][j][0].2.c1),
-                ]);
-
                 let (hinted_script0, hint) = hinted_check_tangent_line(
                     t4,
                     line_coeffs[num_lines - (i + 2)][j][0].1,
@@ -82,26 +76,27 @@ pub fn chunk_q4<T: BCAssigner>(
                 let segment = Segment::new_with_name(
                     format!("check and double_{}", i),
                     script! {
+                        // [fq2(2),c3(2),c4(2),t4(4) ]
+                        {Fq2::roll(8)}
+                        {Fq2::drop()}
+                        // [c3(2),c4(2),t4(4)]
                         { Fq2::copy(2) }
                         { Fq2::toaltstack() }
-                        // [t4 | t4.x]
-                        for _ in 0..4 {
-                            for _ in 0..Fq::N_LIMBS {
-                                OP_DEPTH OP_1SUB OP_ROLL 
-                            }  
-                        } 
-                        // [t4.x, t4.y, a, b | t4.x]
-                        {Fq2::copy(2)} {Fq2::copy(2)}
-                        // [t4.x, t4.y, a, b, a, b | t4.x]
-                        {Fq2::roll(10)} {Fq2::roll(10)}
-                        // [a, b, a, b, t4 | t4.x]
+                        // [c3(2),c4(2),t4(4) | t4.x(2)]
                         {hinted_script0}
                         { Fq2::fromaltstack() }
-                        // [a, b, t4.x]
+                        // [c3(2),c4(2), t4.x(2)]
                         {hinted_script1}
-                        // [t4']
+                        // [c3(2),c4(2),t4'(4)]
+                        { Fq2::roll(6) }
+                        { Fq2::roll(6) }
+                        // [t4'(4), c3(2),c4(2)]
+                        { Fq2::drop() }
+                        { Fq2::drop() }
+                        //[t4'(4)]
                     },
                 )
+                .add_parameter(&line_coeffs_4[num_lines - (i + 2)][0])
                 .add_parameter(&t4_acc)
                 .add_result(&t4_update)
                 .add_hint(hints);
@@ -119,14 +114,7 @@ pub fn chunk_q4<T: BCAssigner>(
             for j in 0..num_line_groups {
                 if j == num_constant {
                     let mut script = script! {};
-
                     let mut hints = vec![];
-                    hints.extend_from_slice(&vec![
-                        Hint::Fq(line_coeffs[num_lines - (i + 2)][j][1].1.c0), 
-                        Hint::Fq(line_coeffs[num_lines - (i + 2)][j][1].1.c1), 
-                        Hint::Fq(line_coeffs[num_lines - (i + 2)][j][1].2.c0), 
-                        Hint::Fq(line_coeffs[num_lines - (i + 2)][j][1].2.c1),
-                    ]);
 
                     let mut pm_q4 = q4;
                     if ark_bn254::Config::ATE_LOOP_COUNT[i - 1] == -1 {
@@ -139,7 +127,6 @@ pub fn chunk_q4<T: BCAssigner>(
                     let y = bias_minus - alpha * x;
                     let t4x = ark_bn254::G2Affine::new(x, y);
 
-
                     let (hinted_script0, hint) = hinted_check_chord_line(
                         t4,
                         pm_q4,
@@ -158,30 +145,27 @@ pub fn chunk_q4<T: BCAssigner>(
 
                     script = script.push_script(
                         script! {
-                             // [t4, pm_q4]
-                            for _ in 0..4 {
-                                for _ in 0..Fq::N_LIMBS {
-                                    OP_DEPTH OP_1SUB OP_ROLL 
-                                }  
-                            }
-                            // [t4, pm_q4, a, b]
-                            {Fq2::copy(2)} {Fq2::copy(2)}
-                            // [t4, pm_q4, a, b, a, b]
-                            {Fq2::roll(14)} {Fq2::roll(14)}
-                            {Fq2::roll(14)} {Fq2::roll(14)}
-                            // [a, b, a, b, t4, pm_q4]
-
-                            // [t4, pm_q4]
+                            // [fq2(2),c3, c4, t4, pm_q4 ]
+                            {Fq2::roll(12)}
+                            {Fq2::drop()}
+                            // [c3, c4, t4, pm_q4]
                             {Fq2::copy(2)}
                             {Fq2::toaltstack()}
                             {Fq2::copy(6)}
                             {Fq2::toaltstack()}
-                            // [a, b, t4, pm_q4]
+                            // [c3, c4, t4, pm_q4 | t4.x, pm_q4.x]
                             {hinted_script0}
+                            //[c3,c4]
                             {Fq2::fromaltstack()}
-                            {Fq2::fromaltstack()} 
-                            // [t4.x, pm_q4.x]
+                            {Fq2::fromaltstack()}
+                            // [c3, c4, t4.x, pm_q4.x]
                             {hinted_script1}
+                            // [c3(2),c4(2),updated_t4]
+                            { Fq2::roll(6) }
+                            { Fq2::roll(6) }
+                            // [updated_t4, c3(2),c4(2)]
+                            { Fq2::drop() }
+                            { Fq2::drop() }
                             // [updated_t4]
                         }
                         .compile(),
@@ -190,6 +174,7 @@ pub fn chunk_q4<T: BCAssigner>(
                     let mut t4_update = G2PointType::new(assigner, &format!("T4_{}_add", i));
                     t4_update.fill_with_data(crate::chunker::elements::DataType::G2PointData(t4x));
                     let segment = Segment::new_with_name(format!("check and add{}", i), script)
+                        .add_parameter(&line_coeffs_4[num_lines - (i + 2)][1])
                         .add_parameter(&t4_acc)
                         .add_parameter(&q4_input)
                         .add_result(&t4_update)
@@ -234,12 +219,6 @@ pub fn chunk_q4<T: BCAssigner>(
             .unwrap();
 
             let mut hints = vec![];
-            hints.extend_from_slice(&vec![
-                Hint::Fq(line_coeffs[num_lines - 2][j][0].1.c0), 
-                Hint::Fq(line_coeffs[num_lines - 2][j][0].1.c1), 
-                Hint::Fq(line_coeffs[num_lines - 2][j][0].2.c0), 
-                Hint::Fq(line_coeffs[num_lines - 2][j][0].2.c1),
-            ]);
 
             let mut q4y = q4.y;
             q4y.conjugate_in_place();
@@ -262,8 +241,6 @@ pub fn chunk_q4<T: BCAssigner>(
             let t4x = ark_bn254::G2Affine::new(x, y);
             let q4_new = ark_bn254::G2Affine::new(q4x, q4y);
 
-
-
             let (check_hinted_script, hint) = hinted_check_chord_line(
                 t4,
                 q4_new,
@@ -281,24 +258,14 @@ pub fn chunk_q4<T: BCAssigner>(
             hints.extend(hint);
 
             let script = script! {
-                    // [t4, q4]
-                for _ in 0..4 {
-                    for _ in 0..Fq::N_LIMBS {
-                        OP_DEPTH OP_1SUB OP_ROLL 
-                    }  
-                }
-                // [t4, q4, a, b]
-                {Fq2::copy(2)} {Fq2::copy(2)}
-                // [t4, q4, a, b, a, b]
-                {Fq2::roll(14)} {Fq2::roll(14)}
-                {Fq2::roll(14)} {Fq2::roll(14)}
-                // [a, b, a, b, t4, q4]
-
-                // [t4, q4]
+                 // [fq2(2),c3, c4, t4, q4 ]
+                 {Fq2::roll(12)}
+                 {Fq2::drop()}
+                // [c3(2), c4(2), t4(4), q4(4)]
                 {Fq::neg(0)}
                 { Fq::push_dec_not_montgomery("2821565182194536844548159561693502659359617185244120367078079554186484126554") }
                 { Fq::push_dec_not_montgomery("3505843767911556378687030309984248845540243509899259641013678093033130930403") }
-                // [t4, q4.x -q4.y, beta13]
+                // [c3(2), c4(2), t4(4), q4.x(2), -q4.y(2), beta13(2)]
                 { q4y_mul_hinted_script }
                 { Fq2::toaltstack() }
 
@@ -310,24 +277,30 @@ pub fn chunk_q4<T: BCAssigner>(
                 { q4x_mul_hinted_script }
                 { Fq2::fromaltstack() }
 
-                
-                // [a, b, a, b, t4, phi_q4]
+                // [t4, phi_q4]
                 {Fq2::copy(2)}
                 {Fq2::toaltstack()}
                 {Fq2::copy(6)}
                 {Fq2::toaltstack()}
-                // [a, b, a, b, t4, phi_q4]
+                // [c3(2), c4(2), t4(4), phi_q4(4)]
                 {check_hinted_script}
                 {Fq2::fromaltstack()}
                 {Fq2::fromaltstack()}
-                // [a, b, t4.x, phi_q4.x]
+                // [c3(2), c4(2), t4.x, phi_q4.x]
                 {add_hinted_script}
-                // [updated_t4]
+                // [c3(2), c4(2), updated_t4]
+                {Fq2::roll(6)}
+                {Fq2::roll(6)}
+                // [ updated_t4, c4(2), c3(2)]
+                {Fq2::drop()}
+                {Fq2::drop()}
+                // [ updated_t4]
             };
 
             let mut t4_update = G2PointType::new(assigner, "T4_final_add");
             t4_update.fill_with_data(crate::chunker::elements::DataType::G2PointData(t4x));
             let segment = Segment::new_with_name("final check and add".into(), script)
+                .add_parameter(&line_coeffs_4[num_lines - 2][0])
                 .add_parameter(&t4_acc)
                 .add_parameter(&q4_input)
                 .add_result(&t4_update)
@@ -355,12 +328,6 @@ pub fn chunk_q4<T: BCAssigner>(
             .unwrap();
 
             let mut hints = vec![];
-            hints.extend_from_slice(&vec![
-                Hint::Fq(line_coeffs[num_lines - 1][j][0].1.c0), 
-                Hint::Fq(line_coeffs[num_lines - 1][j][0].1.c1), 
-                Hint::Fq(line_coeffs[num_lines - 1][j][0].2.c0), 
-                Hint::Fq(line_coeffs[num_lines - 1][j][0].2.c1),
-            ]);
 
             let (mul_x_hinted_script, hint) = Fq2::hinted_mul(2, q4.x, 0, beta_22);
             hints.extend(hint);
@@ -376,28 +343,26 @@ pub fn chunk_q4<T: BCAssigner>(
             hints.extend(hint);
 
             let script = script! {
-                // [t4, q4]
-                for _ in 0..4 {
-                    for _ in 0..Fq::N_LIMBS {
-                        OP_DEPTH OP_1SUB OP_ROLL 
-                    }  
-                }
-                // [t4, q4, a, b]
-                {Fq2::roll(10)} {Fq2::roll(10)}
-                {Fq2::roll(10)} {Fq2::roll(10)}
-                // [a, b, t4, q4]
-
+                // [fq2(2),c3, c4, t4, q4 ]
+                {Fq2::roll(12)}
+                {Fq2::drop()}
+                // [c3(2),c4(2),t4(4), q4(4)]
                 {Fq2::toaltstack()}
-                // [t4, q4x | q4y]
+                // [c3(2),c4(2),t4(4), q4x(2) | q4y(2)]
                 { Fq::push_dec_not_montgomery("21888242871839275220042445260109153167277707414472061641714758635765020556616") }
                 { Fq::push_zero() }
                 {mul_x_hinted_script}
                 { Fq2::fromaltstack() }
-                // [t4, q4x', q4y]
+                // [c3(2),c4(2),t4(4),  q4x'(2), q4y(2)]
                 {check_hinted_script}
+                //[c3(2),c4(2)]
+                {Fq2::drop()}
+                {Fq2::drop()}
+                // []
             };
 
             let segment = Segment::new_with_name("final_final check".into(), script)
+                .add_parameter(&line_coeffs_4[num_lines - 1][0])
                 .add_parameter(&t4_acc)
                 .add_parameter(&q4_input)
                 .add_hint(hints);
@@ -412,8 +377,9 @@ pub fn chunk_q4<T: BCAssigner>(
 mod tests {
     use super::chunk_q4;
     use crate::bn254::ell_coeffs::G2Prepared;
+    use crate::bn254::utils::collect_line_coeffs;
     use crate::chunker::assigner::DummyAssigner;
-    use crate::chunker::elements::{ElementTrait, G2PointType};
+    use crate::chunker::elements::{ElementTrait, DataType::Fq6Data, Fq6Type, G2PointType};
     use crate::execute_script_with_inputs;
     use ark_std::UniformRand;
     use bitcoin::hashes::{sha256::Hash as Sha256, Hash};
@@ -438,8 +404,28 @@ mod tests {
         let mut q4_input = G2PointType::new(&mut assigner, "q4");
         q4_input.fill_with_data(crate::chunker::elements::DataType::G2PointData(q4));
 
+        let constants = [q1_prepared.clone(), q2_prepared.clone(), q3_prepared.clone(), q4_prepared.clone()].to_vec();
+        assert_eq!(constants.len(), 4);
+        let num_line_groups = constants.len();
+        let mut line_coeffs_4: Vec<Vec<Fq6Type>> = vec![];
+        let line_coeffs = collect_line_coeffs(constants);
+        for i in 0..line_coeffs.len() {
+            let line_coeff = &line_coeffs[i];
+            assert_eq!(line_coeff.len(), num_line_groups);
+            let mut line_coeff_4 = vec![];
+            for j in 0..line_coeff[num_line_groups-1].len() {
+                let coeff = &line_coeff[num_line_groups-1][j];
+                let mut fq6 = Fq6Type::new(&mut assigner, &format!("line_coeffs_4_{i}{j}"));
+                let data = ark_bn254::Fq6::new(coeff.0,coeff.1,coeff.2);
+                fq6.fill_with_data(Fq6Data(data));
+                line_coeff_4.push(fq6);
+            }
+            line_coeffs_4.push(line_coeff_4);
+        }
+        
         let segments = chunk_q4(
             [q1_prepared, q2_prepared, q3_prepared, q4_prepared].to_vec(),
+            &line_coeffs_4,
             q4,
             q4_input,
             &mut assigner,