diff --git a/msm/pippenger.cuh b/msm/pippenger.cuh
index 6844e10..8d0417e 100644
--- a/msm/pippenger.cuh
+++ b/msm/pippenger.cuh
@@ -532,10 +532,9 @@ public:
             d_points = (affine_h *)&d_total_blob[offset];
     }
 
-    RustError invoke(point_t& out, const affine_t* points_, size_t npoints,
-                                   const scalar_t* scalars, bool mont = true,
-                                   size_t ffi_affine_sz = sizeof(affine_t))
-    {
+    RustError invoke(point_t &out, const affine_t points[], size_t npoints, 
+                                   const scalar_t *scalars, size_t nscalars,
+                                   uint32_t pidx[], bool mont = true, size_t ffi_affine_sz = sizeof(affine_t)) {
         setup_scratch(points, npoints, nscalars, pidx);
 
         std::vector<result_t> res(nwins);
@@ -554,7 +553,7 @@ public:
                 gpu[2].HtoD(&d_scalars[d_off], &scalars[h_off], num);
             if (pidx)
                 gpu[2].HtoD(&d_pidx[0], &pidx[h_off], num);
-            digits(&d_scalars[0], num, d_digits, d_temps, mont);
+            digits(&d_scalars[0], num, d_digits, d_temps, mont, d_pidx);
             gpu[2].record(ev);
 
             if (points)
@@ -595,7 +594,7 @@ public:
 
                     gpu[2].wait(ev);
                     digits(&d_scalars[scalars ? 0 : h_off], num,
-                           d_digits, d_temps, mont);
+                           d_digits, d_temps, mont, d_pidx);
                     gpu[2].record(ev);
 
                     if (points) {
@@ -632,35 +631,35 @@ public:
         return RustError{cudaSuccess};
     }
 
-    RustError invoke(point_t& out, const affine_t* points, size_t npoints,
-                                   gpu_ptr_t<scalar_t> scalars, bool mont = true,
-                                   size_t ffi_affine_sz = sizeof(affine_t))
-    {
-        d_scalars = scalars;
-        return invoke(out, points, npoints, nullptr, mont, ffi_affine_sz);
-    }
-
-    RustError invoke(point_t& out, vec_t<scalar_t> scalars, bool mont = true)
-    {   return invoke(out, nullptr, scalars.size(), scalars, mont);   }
-
-    RustError invoke(point_t& out, vec_t<affine_t> points,
-                                   const scalar_t* scalars, bool mont = true,
-                                   size_t ffi_affine_sz = sizeof(affine_t))
-    {   return invoke(out, points, points.size(), scalars, mont, ffi_affine_sz);   }
-
-    RustError invoke(point_t& out, vec_t<affine_t> points,
-                                   vec_t<scalar_t> scalars, bool mont = true,
-                                   size_t ffi_affine_sz = sizeof(affine_t))
-    {   return invoke(out, points, points.size(), scalars, mont, ffi_affine_sz);   }
-
-    RustError invoke(point_t& out, const std::vector<affine_t>& points,
-                                   const std::vector<scalar_t>& scalars, bool mont = true,
-                                   size_t ffi_affine_sz = sizeof(affine_t))
-    {
-        return invoke(out, points.data(),
-                           std::min(points.size(), scalars.size()),
-                           scalars.data(), mont, ffi_affine_sz);
-    }
+    // RustError invoke(point_t& out, const affine_t* points, size_t npoints,
+    //                                gpu_ptr_t<scalar_t> scalars, bool mont = true,
+    //                                size_t ffi_affine_sz = sizeof(affine_t))
+    // {
+    //     d_scalars = scalars;
+    //     return invoke(out, points, npoints, nullptr, mont, ffi_affine_sz);
+    // }
+
+    // RustError invoke(point_t& out, vec_t<scalar_t> scalars, bool mont = true)
+    // {   return invoke(out, nullptr, scalars.size(), scalars, mont);   }
+
+    // RustError invoke(point_t& out, vec_t<affine_t> points,
+    //                                const scalar_t* scalars, bool mont = true,
+    //                                size_t ffi_affine_sz = sizeof(affine_t))
+    // {   return invoke(out, points, points.size(), scalars, mont, ffi_affine_sz);   }
+
+    // RustError invoke(point_t& out, vec_t<affine_t> points,
+    //                                vec_t<scalar_t> scalars, bool mont = true,
+    //                                size_t ffi_affine_sz = sizeof(affine_t))
+    // {   return invoke(out, points, points.size(), scalars, mont, ffi_affine_sz);   }
+
+    // RustError invoke(point_t& out, const std::vector<affine_t>& points,
+    //                                const std::vector<scalar_t>& scalars, bool mont = true,
+    //                                size_t ffi_affine_sz = sizeof(affine_t))
+    // {
+    //     return invoke(out, points.data(),
+    //                        std::min(points.size(), scalars.size()),
+    //                        scalars.data(), mont, ffi_affine_sz);
+    // }
 
 private:
     point_t integrate_row(const result_t& row, uint32_t lsbits)
diff --git a/poc/msm-cuda/benches/msm.rs b/poc/msm-cuda/benches/msm.rs
index 35fbfa5..4bf3831 100644
--- a/poc/msm-cuda/benches/msm.rs
+++ b/poc/msm-cuda/benches/msm.rs
@@ -57,11 +57,12 @@ fn criterion_benchmark_fp2(c: &mut Criterion) {
     let name = format!("2**{}", npoints_npow);
     group.bench_function(name, |b| {
         b.iter(|| {
-            let _ = multi_scalar_mult_fp2_arkworks(&points.as_slice(), unsafe {
-                std::mem::transmute::<&[_], &[BigInteger256]>(
-                    scalars.as_slice(),
-                )
-            });
+            let _ =
+                multi_scalar_mult_fp2_arkworks(&points.as_slice(), unsafe {
+                    std::mem::transmute::<&[_], &[BigInteger256]>(
+                        scalars.as_slice(),
+                    )
+                });
         })
     });
 
diff --git a/poc/msm-cuda/cuda/pippenger_inf.cu b/poc/msm-cuda/cuda/pippenger_inf.cu
index f248f94..7b5e3f8 100644
--- a/poc/msm-cuda/cuda/pippenger_inf.cu
+++ b/poc/msm-cuda/cuda/pippenger_inf.cu
@@ -30,7 +30,7 @@ RustError::by_value mult_pippenger_inf(point_t* out, const affine_t points[],
                                        size_t npoints, const scalar_t scalars[],
                                        size_t ffi_affine_sz)
 {
-    return mult_pippenger<bucket_t>(out, points, npoints, scalars, false, ffi_affine_sz);
+    return mult_pippenger<bucket_t>(out, points, npoints, scalars, npoints, nullptr, false);
 }
 
 #if defined(FEATURE_BLS12_381) || defined(FEATURE_BLS12_377)
@@ -43,6 +43,7 @@ RustError::by_value mult_pippenger_fp2_inf(point_fp2_t* out, const affine_fp2_t
                                            size_t npoints, const scalar_t scalars[],
                                            size_t ffi_affine_sz)
 {
-    return mult_pippenger<bucket_fp2_t>(out, points, npoints, scalars, false, ffi_affine_sz);
+    return mult_pippenger<bucket_fp2_t>(out, points, npoints, scalars, npoints, nullptr, false);
+
 }
 #endif