From 2e6f7dca1254a0a9767110de16d71c7302f6d0db Mon Sep 17 00:00:00 2001
From: xevisalle <xavier@dusk.network>
Date: Thu, 9 Nov 2023 01:04:31 +0100
Subject: [PATCH 1/7] Remove MPZ usage from fourier

---
 src/common/fourier.c | 23 ++++++-----------------
 src/common/utils.c   | 12 +++++++++++-
 src/gro16/gro16.h    |  2 ++
 src/gro16/prover.c   |  2 +-
 4 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/src/common/fourier.c b/src/common/fourier.c
index 2540ced..45afa42 100644
--- a/src/common/fourier.c
+++ b/src/common/fourier.c
@@ -28,11 +28,10 @@ void fft(size_t arr, mclBnFr domain[], mclBnFr *o)
     }
 }
 
-void ifft(size_t arr, mclBnFr domain[], mclBnFr *o, mpz_t *Ne)
+void ifft(size_t arr, mclBnFr domain[], mclBnFr *o)
 {
     fft(arr, domain, o);
 
-    mpz_t factor, factor2;
     mclBnFr out[arr];
     mclBnFr frFactor;
 
@@ -41,17 +40,10 @@ void ifft(size_t arr, mclBnFr domain[], mclBnFr *o, mpz_t *Ne)
         out[i] = o[i];
     }
 
-    mpz_init(factor2);
-    mpz_powm(factor2, shift, *Ne, pPrime);
-    mpz_sub_ui(factor2, factor2, 1);
-    mpz_invert(factor2, factor2, pPrime);
+    mclBnFr_setInt(&frFactor, arr);
+    mclBnFr_inv(&frFactor, &frFactor);
+    mclBnFr_mul(&frFactor, &frFactor, &shift_fft);
 
-    mpz_init_set_ui(factor, arr);
-    mpz_invert(factor, factor, pPrime);
-    mpz_mul(factor, factor, factor2);
-    mpz_mod(factor, factor, pPrime);
-
-    mpz_to_fr(&frFactor, &factor);
     mclBnFr_mul(&o[0], &out[0], &frFactor);
 
     for (int i = 1; i < arr; i++)
@@ -71,14 +63,11 @@ void ifft_t(size_t arr, mclBnFr domain[], mclBnFr *o)
         out[i] = o[i];
     }
 
-    mclBnFr frFactor;
-    mpz_to_fr(&frFactor, &rsigma[0]);
-    mclBnFr_mul(&o[0], &out[0], &frFactor);
+    mclBnFr_mul(&o[0], &out[0], &rsigmaFr[0]);
 
     for (int i = 1; i < arr; i++)
     {
-        mpz_to_fr(&frFactor, &rsigma[i]);
-        mclBnFr_mul(&o[i], &out[arr-i], &frFactor);
+        mclBnFr_mul(&o[i], &out[arr-i], &rsigmaFr[i]);
     }
 
     fft(arr, domain, o);
diff --git a/src/common/utils.c b/src/common/utils.c
index 3a2e97b..3853d92 100644
--- a/src/common/utils.c
+++ b/src/common/utils.c
@@ -73,20 +73,28 @@ void init_prover(void *circuit, proving_key pk)
     if (bench) printf("  |--- FFT domain size : %d\n", n);
 
     rsigma = (mpz_t*) malloc((n) * sizeof(mpz_t)); 
+    rsigmaFr = (mclBnFr*) malloc((n) * sizeof(mclBnFr)); 
     rsigmaInv = (mpz_t*) malloc((n) * sizeof(mpz_t)); 
 
     mpz_t randNum;
     mpz_init(randNum);
-    mpz_t factor;
+    mpz_t factor, shift_fft_mpz;
     mpz_init_set_ui(factor, n);
     mpz_invert(factor, factor, pPrime);
     mpz_init(shift);
+    mpz_init(shift_fft_mpz);
 
     mclBnFr rand;
     generate_random_scalar(&rand);
     fr_to_mpz(&randNum, &rand);
     mpz_set(shift, randNum);
 
+    mpz_powm(shift_fft_mpz, shift, pk.Ne, pPrime);
+    mpz_sub_ui(shift_fft_mpz, shift_fft_mpz, 1);
+    mpz_invert(shift_fft_mpz, shift_fft_mpz, pPrime);
+
+    mpz_to_fr(&shift_fft, &shift_fft_mpz);
+
     mpz_init2(rsigma[0], BITS);
     mpz_init2(rsigmaInv[0], BITS);
     mpz_set_ui(rsigma[0], 1);
@@ -97,6 +105,7 @@ void init_prover(void *circuit, proving_key pk)
     mclBnG1_mul(&pk.xt1_rand[0], &pk.xt1[0], &frFactor);
     mpz_mul(rsigma[0], rsigma[0], factor);
     mpz_mod(rsigma[0], rsigma[0], pPrime);
+    mpz_to_fr(&rsigmaFr[0], &rsigma[0]);
 
     for (int i = 1; i < n; i++)
     {
@@ -111,6 +120,7 @@ void init_prover(void *circuit, proving_key pk)
 
         mpz_mul(rsigma[i], rsigma[i], factor);
         mpz_mod(rsigma[i], rsigma[i], pPrime);
+        mpz_to_fr(&rsigmaFr[i], &rsigma[i]);
     }
 
     clock_gettime(CLOCK_MONOTONIC, &end);
diff --git a/src/gro16/gro16.h b/src/gro16/gro16.h
index ba7ff13..ef50b55 100644
--- a/src/gro16/gro16.h
+++ b/src/gro16/gro16.h
@@ -46,8 +46,10 @@ static mclBnFr *BsFr;
 static mclBnFr *CsFr;
 
 static mpz_t *rsigma;
+static mclBnFr *rsigmaFr;
 static mpz_t *rsigmaInv;
 static mpz_t shift;
+static mclBnFr shift_fft;
 
 static mpz_t *wM;
 
diff --git a/src/gro16/prover.c b/src/gro16/prover.c
index edde8a8..d678b44 100644
--- a/src/gro16/prover.c
+++ b/src/gro16/prover.c
@@ -89,7 +89,7 @@ void h_coefficients(proving_key pk)
         mclBnFr_sub(&AsFr[i], &AsFr[i], &CsFr[i]);
     }
 
-    ifft(n, pk.wMFr, AsFr, &pk.Ne);
+    ifft(n, pk.wMFr, AsFr);
 }
 
 void mul_exp(struct mulExpResult *result, mpz_t *uwProof, proving_key pk)

From 82a203537baafdfbeb15c6c18f7bc82e3f443076 Mon Sep 17 00:00:00 2001
From: xevisalle <xavier@dusk.network>
Date: Thu, 9 Nov 2023 01:46:34 +0100
Subject: [PATCH 2/7] rsigma to mcl

---
 src/common/fourier.c |  4 ++--
 src/common/utils.c   | 57 +++++++++++++++++++-------------------------
 src/gro16/gro16.h    |  6 ++---
 src/zpie.c           |  4 ++--
 4 files changed, 31 insertions(+), 40 deletions(-)

diff --git a/src/common/fourier.c b/src/common/fourier.c
index 45afa42..dd7b99a 100644
--- a/src/common/fourier.c
+++ b/src/common/fourier.c
@@ -63,11 +63,11 @@ void ifft_t(size_t arr, mclBnFr domain[], mclBnFr *o)
         out[i] = o[i];
     }
 
-    mclBnFr_mul(&o[0], &out[0], &rsigmaFr[0]);
+    mclBnFr_mul(&o[0], &out[0], &rsigma[0]);
 
     for (int i = 1; i < arr; i++)
     {
-        mclBnFr_mul(&o[i], &out[arr-i], &rsigmaFr[i]);
+        mclBnFr_mul(&o[i], &out[arr-i], &rsigma[i]);
     }
 
     fft(arr, domain, o);
diff --git a/src/common/utils.c b/src/common/utils.c
index 3853d92..69b05f6 100644
--- a/src/common/utils.c
+++ b/src/common/utils.c
@@ -72,22 +72,16 @@ void init_prover(void *circuit, proving_key pk)
     mpz_set_str(pPrime, PRIMESTR, 10);
     if (bench) printf("  |--- FFT domain size : %d\n", n);
 
-    rsigma = (mpz_t*) malloc((n) * sizeof(mpz_t)); 
-    rsigmaFr = (mclBnFr*) malloc((n) * sizeof(mclBnFr)); 
-    rsigmaInv = (mpz_t*) malloc((n) * sizeof(mpz_t)); 
-
-    mpz_t randNum;
-    mpz_init(randNum);
-    mpz_t factor, shift_fft_mpz;
-    mpz_init_set_ui(factor, n);
-    mpz_invert(factor, factor, pPrime);
+    rsigma = (mclBnFr*) malloc((n) * sizeof(mclBnFr)); 
+    rsigmaInv = (mclBnFr*) malloc((n) * sizeof(mclBnFr)); 
+
+    mpz_t shift_fft_mpz;
     mpz_init(shift);
     mpz_init(shift_fft_mpz);
 
     mclBnFr rand;
     generate_random_scalar(&rand);
-    fr_to_mpz(&randNum, &rand);
-    mpz_set(shift, randNum);
+    fr_to_mpz(&shift, &rand);
 
     mpz_powm(shift_fft_mpz, shift, pk.Ne, pPrime);
     mpz_sub_ui(shift_fft_mpz, shift_fft_mpz, 1);
@@ -95,32 +89,29 @@ void init_prover(void *circuit, proving_key pk)
 
     mpz_to_fr(&shift_fft, &shift_fft_mpz);
 
-    mpz_init2(rsigma[0], BITS);
-    mpz_init2(rsigmaInv[0], BITS);
-    mpz_set_ui(rsigma[0], 1);
-    mpz_invert(rsigmaInv[0], rsigma[0], pPrime);
+    mclBnFr_setInt(&rsigma[0], 1);
+    mclBnFr_inv(&rsigmaInv[0], &rsigma[0]);
 
-    mclBnFr frFactor;
-    mpz_to_fr(&frFactor, &rsigmaInv[0]);
-    mclBnG1_mul(&pk.xt1_rand[0], &pk.xt1[0], &frFactor);
-    mpz_mul(rsigma[0], rsigma[0], factor);
-    mpz_mod(rsigma[0], rsigma[0], pPrime);
-    mpz_to_fr(&rsigmaFr[0], &rsigma[0]);
+    mclBnG1_mul(&pk.xt1_rand[0], &pk.xt1[0], &rsigmaInv[0]);
+
+    mclBnFr n_inverted;
+    mclBnFr_setInt(&n_inverted, n);
+    mclBnFr_inv(&n_inverted, &n_inverted);
+
+    mclBnFr_mul(&rsigma[0], &rsigma[0], &n_inverted);
 
     for (int i = 1; i < n; i++)
     {
-        mclBnFr frFactorMulti;
-        mpz_init2(rsigma[i], BITS);
-        mpz_init2(rsigmaInv[i], BITS);
-        mpz_powm_ui(rsigma[i], shift, i, pPrime);
-        mpz_invert(rsigmaInv[i], rsigma[i], pPrime);
-
-        mpz_to_fr(&frFactorMulti, &rsigmaInv[i]);
-        mclBnG1_mul(&pk.xt1_rand[i], &pk.xt1[i], &frFactorMulti);
-
-        mpz_mul(rsigma[i], rsigma[i], factor);
-        mpz_mod(rsigma[i], rsigma[i], pPrime);
-        mpz_to_fr(&rsigmaFr[i], &rsigma[i]);
+        mpz_t factor;
+        mpz_init(factor);
+        mpz_powm_ui(factor, shift, i, pPrime);
+
+        mpz_to_fr(&rsigma[i], &factor);
+
+        mclBnFr_inv(&rsigmaInv[i], &rsigma[i]);
+        mclBnG1_mul(&pk.xt1_rand[i], &pk.xt1[i], &rsigmaInv[i]);
+
+        mclBnFr_mul(&rsigma[i], &rsigma[i], &n_inverted);
     }
 
     clock_gettime(CLOCK_MONOTONIC, &end);
diff --git a/src/gro16/gro16.h b/src/gro16/gro16.h
index ef50b55..42c76ce 100644
--- a/src/gro16/gro16.h
+++ b/src/gro16/gro16.h
@@ -45,9 +45,9 @@ static mclBnFr *AsFr;
 static mclBnFr *BsFr;
 static mclBnFr *CsFr;
 
-static mpz_t *rsigma;
-static mclBnFr *rsigmaFr;
-static mpz_t *rsigmaInv;
+static mclBnFr *rsigma;
+static mclBnFr *rsigmaInv;
+
 static mpz_t shift;
 static mclBnFr shift_fft;
 
diff --git a/src/zpie.c b/src/zpie.c
index c894ac2..51e24c1 100644
--- a/src/zpie.c
+++ b/src/zpie.c
@@ -409,8 +409,8 @@ proof generate_proof(void *circuit, proving_key pk)
         mclBnFr_clear(&BsFr[i]);
         mclBnFr_clear(&CsFr[i]);
 
-        mpz_clear(rsigma[i]);
-        mpz_clear(rsigmaInv[i]);
+        mclBnFr_clear(&rsigma[i]);
+        mclBnFr_clear(&rsigmaInv[i]);
     }
 
     for (int i = 0; i < M; i++)

From 8656ae70554c4292e2eeab5a769ce705d63791a9 Mon Sep 17 00:00:00 2001
From: xevisalle <xavier@dusk.network>
Date: Thu, 9 Nov 2023 02:29:47 +0100
Subject: [PATCH 3/7] Improve pointers usage

---
 src/bench.c          |  4 +--
 src/common/utils.c   | 29 ++++++++--------
 src/gro16/gro16.h    |  2 --
 src/gro16/prover.c   | 82 ++++++++++++++++++++++----------------------
 src/gro16/verifier.c | 24 ++++++-------
 src/tests.c          | 14 ++++----
 src/zpie.c           | 10 +++---
 src/zpie.h           |  6 ++--
 8 files changed, 83 insertions(+), 88 deletions(-)

diff --git a/src/bench.c b/src/bench.c
index b18756a..c6c0335 100644
--- a/src/bench.c
+++ b/src/bench.c
@@ -77,14 +77,14 @@ int main(int argc, char *argv[])
     else if (strcmp(argv[1], "-p") == 0)
     {
         setup_keys keys = read_setup(&bench_circuit);
-        proof p = generate_proof(&bench_circuit, keys.pk);
+        proof p = generate_proof(&bench_circuit, &keys.pk);
         store_proof(&p);
     }
     else if (strcmp(argv[1], "-v") == 0)
     {
         setup_keys keys = read_setup(&bench_circuit);
         proof p = read_proof();
-        verify_proof(&bench_circuit, p, keys.vk);
+        verify_proof(&bench_circuit, &p, &keys.vk);
     }
 
     return 0;
diff --git a/src/common/utils.c b/src/common/utils.c
index 69b05f6..f7ce452 100644
--- a/src/common/utils.c
+++ b/src/common/utils.c
@@ -54,7 +54,7 @@ void init_setup(void *circuit)
     }
 }
 
-void init_prover(void *circuit, proving_key pk)
+void init_prover(void *circuit, proving_key *pk)
 {
     init_setup(circuit);
 
@@ -62,7 +62,7 @@ void init_prover(void *circuit, proving_key pk)
     double elapsed;
     clock_gettime(CLOCK_MONOTONIC, &begin);
 
-    int n = mpz_get_ui(pk.Ne);
+    int n = mpz_get_ui(pk->Ne);
 
     AsFr = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
     BsFr = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
@@ -75,24 +75,23 @@ void init_prover(void *circuit, proving_key pk)
     rsigma = (mclBnFr*) malloc((n) * sizeof(mclBnFr)); 
     rsigmaInv = (mclBnFr*) malloc((n) * sizeof(mclBnFr)); 
 
-    mpz_t shift_fft_mpz;
+    static mpz_t shift;
     mpz_init(shift);
-    mpz_init(shift_fft_mpz);
 
     mclBnFr rand;
     generate_random_scalar(&rand);
     fr_to_mpz(&shift, &rand);
 
-    mpz_powm(shift_fft_mpz, shift, pk.Ne, pPrime);
-    mpz_sub_ui(shift_fft_mpz, shift_fft_mpz, 1);
-    mpz_invert(shift_fft_mpz, shift_fft_mpz, pPrime);
+    mpz_powm(shift, shift, pk->Ne, pPrime);
+    mpz_sub_ui(shift, shift, 1);
+    mpz_invert(shift, shift, pPrime);
 
-    mpz_to_fr(&shift_fft, &shift_fft_mpz);
+    mpz_to_fr(&shift_fft, &shift);
 
     mclBnFr_setInt(&rsigma[0], 1);
     mclBnFr_inv(&rsigmaInv[0], &rsigma[0]);
 
-    mclBnG1_mul(&pk.xt1_rand[0], &pk.xt1[0], &rsigmaInv[0]);
+    mclBnG1_mul(&pk->xt1_rand[0], &pk->xt1[0], &rsigmaInv[0]);
 
     mclBnFr n_inverted;
     mclBnFr_setInt(&n_inverted, n);
@@ -100,16 +99,16 @@ void init_prover(void *circuit, proving_key pk)
 
     mclBnFr_mul(&rsigma[0], &rsigma[0], &n_inverted);
 
+    mclBnFr one;
+    mclBnFr_setInt(&one, 1);
+    mclBnFr_mul(&rsigma[1], &rand, &one);
+
     for (int i = 1; i < n; i++)
     {
-        mpz_t factor;
-        mpz_init(factor);
-        mpz_powm_ui(factor, shift, i, pPrime);
-
-        mpz_to_fr(&rsigma[i], &factor);
+        if (i < n - 1) mclBnFr_mul(&rsigma[i + 1], &rsigma[i], &rand);
 
         mclBnFr_inv(&rsigmaInv[i], &rsigma[i]);
-        mclBnG1_mul(&pk.xt1_rand[i], &pk.xt1[i], &rsigmaInv[i]);
+        mclBnG1_mul(&pk->xt1_rand[i], &pk->xt1[i], &rsigmaInv[i]);
 
         mclBnFr_mul(&rsigma[i], &rsigma[i], &n_inverted);
     }
diff --git a/src/gro16/gro16.h b/src/gro16/gro16.h
index 42c76ce..4b4c0d2 100644
--- a/src/gro16/gro16.h
+++ b/src/gro16/gro16.h
@@ -47,8 +47,6 @@ static mclBnFr *CsFr;
 
 static mclBnFr *rsigma;
 static mclBnFr *rsigmaInv;
-
-static mpz_t shift;
 static mclBnFr shift_fft;
 
 static mpz_t *wM;
diff --git a/src/gro16/prover.c b/src/gro16/prover.c
index d678b44..7ed8874 100644
--- a/src/gro16/prover.c
+++ b/src/gro16/prover.c
@@ -1,7 +1,7 @@
 
-void h_coefficients(proving_key pk)
+void h_coefficients(proving_key *pk)
 {
-    int n = mpz_get_ui(pk.Ne);
+    int n = mpz_get_ui(pk->Ne);
     mclBnFr uwFr[M];
 
     #pragma omp parallel for
@@ -21,46 +21,46 @@ void h_coefficients(proving_key pk)
     int l_it = 0;
     int r_it = 1;
 
-    for (int j = 0; j < pk.qap_size; j+=3)
+    for (int j = 0; j < pk->qap_size; j+=3)
     {
-        switch (pk.LRO[j])
+        switch (pk->LRO[j])
         {
-            case 1: mclBnFr_add(&AsFr[pk.LRO[j+1]], &AsFr[pk.LRO[j+1]], &uwFr[pk.LRO[j+2]]); break;
-            case 2: mclBnFr_add(&BsFr[pk.LRO[j+1]], &BsFr[pk.LRO[j+1]], &uwFr[pk.LRO[j+2]]); break;
-            case 3: mclBnFr_add(&CsFr[pk.LRO[j+1]], &CsFr[pk.LRO[j+1]], &uwFr[pk.LRO[j+2]]); break;
+            case 1: mclBnFr_add(&AsFr[pk->LRO[j+1]], &AsFr[pk->LRO[j+1]], &uwFr[pk->LRO[j+2]]); break;
+            case 2: mclBnFr_add(&BsFr[pk->LRO[j+1]], &BsFr[pk->LRO[j+1]], &uwFr[pk->LRO[j+2]]); break;
+            case 3: mclBnFr_add(&CsFr[pk->LRO[j+1]], &CsFr[pk->LRO[j+1]], &uwFr[pk->LRO[j+2]]); break;
             case 10:
             {
                 mclBnFr factorFr;
-                if (pk.LRO[j+3] != INT_MAX)
+                if (pk->LRO[j+3] != INT_MAX)
                 {
-                    mclBnFr_setInt(&factorFr, pk.LRO[j+3]);
-                    mclBnFr_mul(&factorFr, &uwFr[pk.LRO[j+2]], &factorFr);
+                    mclBnFr_setInt(&factorFr, pk->LRO[j+3]);
+                    mclBnFr_mul(&factorFr, &uwFr[pk->LRO[j+2]], &factorFr);
                 }
                 else
                 {
-                    mpz_to_fr(&factorFr, &pk.LRO_constants[l_it]);
-                    mclBnFr_mul(&factorFr, &uwFr[pk.LRO[j+2]], &factorFr);
+                    mpz_to_fr(&factorFr, &pk->LRO_constants[l_it]);
+                    mclBnFr_mul(&factorFr, &uwFr[pk->LRO[j+2]], &factorFr);
                     l_it+=2;
                 }
-                mclBnFr_add(&AsFr[pk.LRO[j+1]], &AsFr[pk.LRO[j+1]], &factorFr); 
+                mclBnFr_add(&AsFr[pk->LRO[j+1]], &AsFr[pk->LRO[j+1]], &factorFr); 
                 j+=1;
                 break;
             }
             case 20:
             {
                 mclBnFr factorFr;
-                if (pk.LRO[j+3] != INT_MAX)
+                if (pk->LRO[j+3] != INT_MAX)
                 {
-                    mclBnFr_setInt(&factorFr, pk.LRO[j+3]);
-                    mclBnFr_mul(&factorFr, &uwFr[pk.LRO[j+2]], &factorFr);
+                    mclBnFr_setInt(&factorFr, pk->LRO[j+3]);
+                    mclBnFr_mul(&factorFr, &uwFr[pk->LRO[j+2]], &factorFr);
                 }
                 else
                 {
-                    mpz_to_fr(&factorFr, &pk.LRO_constants[r_it]);
-                    mclBnFr_mul(&factorFr, &uwFr[pk.LRO[j+2]], &factorFr);
+                    mpz_to_fr(&factorFr, &pk->LRO_constants[r_it]);
+                    mclBnFr_mul(&factorFr, &uwFr[pk->LRO[j+2]], &factorFr);
                     r_it+=2;
                 }
-                mclBnFr_add(&BsFr[pk.LRO[j+1]], &BsFr[pk.LRO[j+1]], &factorFr);
+                mclBnFr_add(&BsFr[pk->LRO[j+1]], &BsFr[pk->LRO[j+1]], &factorFr);
                 j+=1; 
                 break;
             }
@@ -71,13 +71,13 @@ void h_coefficients(proving_key pk)
     {
         switch (get_thread())
         {
-            case 0: ifft_t(n, pk.wMFr, AsFr); break;
-            case 1: ifft_t(n, pk.wMFr, BsFr); break;
-            case 2: ifft_t(n, pk.wMFr, CsFr); break;
+            case 0: ifft_t(n, pk->wMFr, AsFr); break;
+            case 1: ifft_t(n, pk->wMFr, BsFr); break;
+            case 2: ifft_t(n, pk->wMFr, CsFr); break;
             case 99:
-                ifft_t(n, pk.wMFr, AsFr);
-                ifft_t(n, pk.wMFr, BsFr);
-                ifft_t(n, pk.wMFr, CsFr);
+                ifft_t(n, pk->wMFr, AsFr);
+                ifft_t(n, pk->wMFr, BsFr);
+                ifft_t(n, pk->wMFr, CsFr);
                 break;
         }
     }
@@ -89,12 +89,12 @@ void h_coefficients(proving_key pk)
         mclBnFr_sub(&AsFr[i], &AsFr[i], &CsFr[i]);
     }
 
-    ifft(n, pk.wMFr, AsFr);
+    ifft(n, pk->wMFr, AsFr);
 }
 
-void mul_exp(struct mulExpResult *result, mpz_t *uwProof, proving_key pk)
+void mul_exp(struct mulExpResult *result, mpz_t *uwProof, proving_key *pk)
 {
-    int n = mpz_get_ui(pk.Ne);
+    int n = mpz_get_ui(pk->Ne);
 
     mclBnFr uwFactor[M];
     mclBnFr uwFactorPublic[M-(nPublic + nConst)];
@@ -117,14 +117,14 @@ void mul_exp(struct mulExpResult *result, mpz_t *uwProof, proving_key pk)
         int num_threads = get_nprocs();
     #endif
 
-    mclBnG1_mulVecMT(&result->uwA1, pk.A1, uwFactor, M, num_threads);
-    mclBnG1_mulVecMT(&result->uwB1, pk.B1, uwFactor, M, num_threads);
-    mclBnG2_mulVecMT(&result->uwB2, pk.B2, uwFactor, M, num_threads);
-    mclBnG1_mulVecMT(&result->uwC1, pk.pk1, uwFactorPublic, M-(nPublic + nConst), num_threads);
-    mclBnG1_mulVecMT(&result->htdelta, pk.xt1_rand, AsFr, n, num_threads);
+    mclBnG1_mulVecMT(&result->uwA1, pk->A1, uwFactor, M, num_threads);
+    mclBnG1_mulVecMT(&result->uwB1, pk->B1, uwFactor, M, num_threads);
+    mclBnG2_mulVecMT(&result->uwB2, pk->B2, uwFactor, M, num_threads);
+    mclBnG1_mulVecMT(&result->uwC1, pk->pk1, uwFactorPublic, M-(nPublic + nConst), num_threads);
+    mclBnG1_mulVecMT(&result->htdelta, pk->xt1_rand, AsFr, n, num_threads);
 }
 
-void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mpz_t *uwProof, proving_key pk)
+void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mpz_t *uwProof, proving_key *pk)
 {
     prover = 1;
 
@@ -169,22 +169,22 @@ void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mpz_t *uwPro
     generate_random_scalar(&s);
 
     // piA = s1.alpha + Auw + r * s1.delta;
-    mclBnG1_mul(piA, &pk.delta1, &r);
+    mclBnG1_mul(piA, &pk->delta1, &r);
     mclBnG1_add(piA, piA, &result.uwA1);
-    mclBnG1_add(piA, piA, &pk.alpha1);
+    mclBnG1_add(piA, piA, &pk->alpha1);
     // piB1 = s1.beta + B1uw + s * s1.delta;
-    mclBnG1_mul(&piB1, &pk.delta1, &s);
+    mclBnG1_mul(&piB1, &pk->delta1, &s);
     mclBnG1_add(&piB1, &piB1, &result.uwB1);
-    mclBnG1_add(&piB1, &piB1, &pk.beta1);
+    mclBnG1_add(&piB1, &piB1, &pk->beta1);
     // piB2 = s2.beta + B2uw + s * s2.delta;
-    mclBnG2_mul(piB2, &pk.delta2, &s);
+    mclBnG2_mul(piB2, &pk->delta2, &s);
     mclBnG2_add(piB2, piB2, &result.uwB2);
-    mclBnG2_add(piB2, piB2, &pk.beta2);
+    mclBnG2_add(piB2, piB2, &pk->beta2);
 
     mclBnG1 factorG1;
 
     // piC = Cw + htdelta + piA*s + piB*r - r*s*s1.delta
-    mclBnG1_mul(&factorG1, &pk.delta1, &r);
+    mclBnG1_mul(&factorG1, &pk->delta1, &r);
     mclBnG1_mul(&factorG1, &factorG1, &s);
     mclBnG1_mul(piC, &piB1, &r);
     mclBnG1_sub(&factorG1, piC, &factorG1);
diff --git a/src/gro16/verifier.c b/src/gro16/verifier.c
index ae2e167..6f0acaf 100644
--- a/src/gro16/verifier.c
+++ b/src/gro16/verifier.c
@@ -1,5 +1,5 @@
 
-int verify(mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mpz_t u[(nPublic + nConst)], verifying_key vk)
+int verify(proof *p, verifying_key *vk)
 {
     mclBnG1 factorG1;
     mclBnFr frFactor;
@@ -10,16 +10,16 @@ int verify(mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mpz_t u[(nPublic + nConst)
     for (int i = (nPublic); i--;)
     {
         // Vu = Vu + u[i] * s1.vk[i]
-        mpz_to_fr(&frFactor, &u[i]);
-        mclBnG1_mul(&factorG1, &vk.vk1[i+nConst], &frFactor);
+        mpz_to_fr(&frFactor, &p->uwProof[i]);
+        mclBnG1_mul(&factorG1, &vk->vk1[i+nConst], &frFactor);
         mclBnG1_add(&Vu, &Vu, &factorG1);
     }
 
     for (int i = (nConst); i--;)
     {
         // Vu = Vu + u[i] * s1.vk[i]
-        mpz_to_fr(&frFactor, &vk.constants[i]);
-        mclBnG1_mul(&factorG1, &vk.vk1[i], &frFactor);
+        mpz_to_fr(&frFactor, &vk->constants[i]);
+        mclBnG1_mul(&factorG1, &vk->vk1[i], &frFactor);
         mclBnG1_add(&Vu, &Vu, &factorG1);
     }
 
@@ -29,13 +29,13 @@ int verify(mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mpz_t u[(nPublic + nConst)
     {
         switch (get_thread())
         {
-            case 0: mclBn_pairing(&pairing1, piA, piB2); break;
-            case 1: mclBn_pairing(&pairing2, &Vu, &vk.gamma2); break;
-            case 2: mclBn_pairing(&pairing3, piC, &vk.delta2); break;
+            case 0: mclBn_pairing(&pairing1, &p->piA, &p->piB2); break;
+            case 1: mclBn_pairing(&pairing2, &Vu, &vk->gamma2); break;
+            case 2: mclBn_pairing(&pairing3, &p->piC, &vk->delta2); break;
             case 99:
-                mclBn_pairing(&pairing1, piA, piB2);
-                mclBn_pairing(&pairing2, &Vu, &vk.gamma2);
-                mclBn_pairing(&pairing3, piC, &vk.delta2);
+                mclBn_pairing(&pairing1, &p->piA, &p->piB2);
+                mclBn_pairing(&pairing2, &Vu, &vk->gamma2);
+                mclBn_pairing(&pairing3, &p->piC, &vk->delta2);
                 break;
         }
     }
@@ -53,7 +53,7 @@ int verify(mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mpz_t u[(nPublic + nConst)
     }
 
     log_message("Computing e(alpha, beta) * e(Vu, gamma) * e(piC, delta)...");
-    mclBnGT_mul(&factorGT, &vk.alphabetaT, &pairing2);
+    mclBnGT_mul(&factorGT, &vk->alphabetaT, &pairing2);
     mclBnGT_mul(&factorGT, &factorGT, &pairing3);
     log_state(1);
     if (logs)
diff --git a/src/tests.c b/src/tests.c
index a280ee2..ea0348f 100644
--- a/src/tests.c
+++ b/src/tests.c
@@ -56,7 +56,7 @@ void test_prover(void)
 {
     test_no_rand = 1;
     setup_keys keys = perform_setup(&test_single_constraint); 
-    proof p = generate_proof(&test_single_constraint, keys.pk);
+    proof p = generate_proof(&test_single_constraint, &keys.pk);
 
     const char *piAstr = "1 13398732126763033363928255770670403609664455533535809960659793057603927642327 14567332642717250669329472598965177550050834309459245026995104363234319745805";
     const char *piB2str = "1 9513526328373247288214002967710658327692956864193416721895179753121227228903 17320346092699268035923233491595138958007151833266586455159840335219170425243 8079768110185479532548096263199181437927983909022782182442306192699700743609 19381997603489315175356927627025590277145986935796790438444340629346184509934";
@@ -82,13 +82,13 @@ void test_full_circuits(void)
     setup_keys keys_mh = perform_setup(&test_mimc_hash);  
     setup_keys keys_ev = perform_setup(&test_eddsa_verification); 
 
-    proof p_sc = generate_proof(&test_single_constraint, keys_sc.pk);
-    proof p_mh = generate_proof(&test_mimc_hash, keys_mh.pk);
-    proof p_ev = generate_proof(&test_eddsa_verification, keys_ev.pk);
+    proof p_sc = generate_proof(&test_single_constraint, &keys_sc.pk);
+    proof p_mh = generate_proof(&test_mimc_hash, &keys_mh.pk);
+    proof p_ev = generate_proof(&test_eddsa_verification, &keys_ev.pk);
     
-    CU_ASSERT(verify_proof(&test_single_constraint, p_sc, keys_sc.vk));
-    CU_ASSERT(verify_proof(&test_mimc_hash, p_mh, keys_mh.vk));
-    CU_ASSERT(verify_proof(&test_eddsa_verification, p_ev, keys_ev.vk));
+    CU_ASSERT(verify_proof(&test_single_constraint, &p_sc, &keys_sc.vk));
+    CU_ASSERT(verify_proof(&test_mimc_hash, &p_mh, &keys_mh.vk));
+    CU_ASSERT(verify_proof(&test_eddsa_verification, &p_ev, &keys_ev.vk));
 }
 
 //TODO: fix this
diff --git a/src/zpie.c b/src/zpie.c
index 51e24c1..c5dc287 100644
--- a/src/zpie.c
+++ b/src/zpie.c
@@ -365,7 +365,7 @@ setup_keys read_setup(void *circuit)
     return keys;
 }
 
-proof generate_proof(void *circuit, proving_key pk)
+proof generate_proof(void *circuit, proving_key *pk)
 {
     init_prover(circuit, pk);
 
@@ -377,7 +377,7 @@ proof generate_proof(void *circuit, proving_key pk)
         mpz_init(uw[i]);
     }
 
-    int n = mpz_get_ui(pk.Ne);
+    int n = mpz_get_ui(pk->Ne);
     wM = (mpz_t*) malloc((n) * sizeof(mpz_t));
     
     proof p;
@@ -418,8 +418,6 @@ proof generate_proof(void *circuit, proving_key pk)
         mpz_clear(uw[i]);
     }
 
-    mpz_clear(shift);
-
     return p;
 }
 
@@ -472,7 +470,7 @@ proof read_proof()
     return p;
 }
 
-int verify_proof(void *circuit, proof p, verifying_key vk)
+int verify_proof(void *circuit, proof *p, verifying_key *vk)
 {
     init_setup(circuit);
 
@@ -480,7 +478,7 @@ int verify_proof(void *circuit, proof p, verifying_key vk)
     double elapsed;
     clock_gettime(CLOCK_MONOTONIC, &begin);
 
-    int verified = verify(&p.piA, &p.piB2, &p.piC, p.uwProof, vk);
+    int verified = verify(p, vk);
 
     if (verified)
     {
diff --git a/src/zpie.h b/src/zpie.h
index b3fd45a..aa5108b 100644
--- a/src/zpie.h
+++ b/src/zpie.h
@@ -85,9 +85,9 @@ static inline void bulletproof_get_context(context *ctx);
 static inline void bulletproof_user_gammas(int val);
 void init_setup(void *circuit);
 setup_keys perform_setup(void *circuit);
-void init_prover(void *circuit, proving_key pk);
-proof generate_proof(void *circuit, proving_key pk);
-int verify_proof(void *circuit, proof p, verifying_key vk);
+void init_prover(void *circuit, proving_key *pk);
+proof generate_proof(void *circuit, proving_key *pk);
+int verify_proof(void *circuit, proof *p, verifying_key *vk);
 
 #include "zpie.c"
 #include "bulletproofs/bulletproofs.c"
\ No newline at end of file

From e9431b8236213202a629585fa40e86e898cf5df9 Mon Sep 17 00:00:00 2001
From: xevisalle <xavier@dusk.network>
Date: Thu, 9 Nov 2023 02:50:40 +0100
Subject: [PATCH 4/7] proof to mcl

---
 src/gro16/prover.c   |  6 +++---
 src/gro16/verifier.c |  3 +--
 src/zpie.c           | 29 ++++++++++++-----------------
 src/zpie.h           |  2 +-
 4 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/src/gro16/prover.c b/src/gro16/prover.c
index 7ed8874..e62d4ac 100644
--- a/src/gro16/prover.c
+++ b/src/gro16/prover.c
@@ -92,7 +92,7 @@ void h_coefficients(proving_key *pk)
     ifft(n, pk->wMFr, AsFr);
 }
 
-void mul_exp(struct mulExpResult *result, mpz_t *uwProof, proving_key *pk)
+void mul_exp(struct mulExpResult *result, mclBnFr *uwProof, proving_key *pk)
 {
     int n = mpz_get_ui(pk->Ne);
 
@@ -101,7 +101,7 @@ void mul_exp(struct mulExpResult *result, mpz_t *uwProof, proving_key *pk)
 
     for (int i = nConst; i < (nPublic + nConst); i++)
     {
-        mpz_set(uwProof[i-nConst], uw[i]);
+        mpz_to_fr(&uwProof[i-nConst], &uw[i]);
     }
 
     #pragma omp parallel for
@@ -124,7 +124,7 @@ void mul_exp(struct mulExpResult *result, mpz_t *uwProof, proving_key *pk)
     mclBnG1_mulVecMT(&result->htdelta, pk->xt1_rand, AsFr, n, num_threads);
 }
 
-void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mpz_t *uwProof, proving_key *pk)
+void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mclBnFr *uwProof, proving_key *pk)
 {
     prover = 1;
 
diff --git a/src/gro16/verifier.c b/src/gro16/verifier.c
index 6f0acaf..3aec82c 100644
--- a/src/gro16/verifier.c
+++ b/src/gro16/verifier.c
@@ -10,8 +10,7 @@ int verify(proof *p, verifying_key *vk)
     for (int i = (nPublic); i--;)
     {
         // Vu = Vu + u[i] * s1.vk[i]
-        mpz_to_fr(&frFactor, &p->uwProof[i]);
-        mclBnG1_mul(&factorG1, &vk->vk1[i+nConst], &frFactor);
+        mclBnG1_mul(&factorG1, &vk->vk1[i+nConst], &p->uwProof[i]);
         mclBnG1_add(&Vu, &Vu, &factorG1);
     }
 
diff --git a/src/zpie.c b/src/zpie.c
index c5dc287..bf69cb2 100644
--- a/src/zpie.c
+++ b/src/zpie.c
@@ -382,12 +382,7 @@ proof generate_proof(void *circuit, proving_key *pk)
     
     proof p;
 
-    p.uwProof = (mpz_t*) malloc((nPublic) * sizeof(mpz_t));
-
-    for (int i = 0; i < (nPublic); i++)
-    {
-        mpz_init(p.uwProof[i]);
-    }
+    p.uwProof = (mclBnFr*) malloc((nPublic) * sizeof(mclBnFr));
 
     if (bench) printf("--- Computing proof...\n");
     struct timespec begin, end;
@@ -427,14 +422,14 @@ void store_proof(proof *p)
     FILE *fproof;
     fproof = fopen("data/proof.params", "w");
 
+    int size = 0;
+
     for (int i = 0; i < (nPublic); i++)
     {
-        mpz_out_raw(fproof, p->uwProof[i]);
+        size += mclBnFr_serialize(buff + size, SIZE_FR, &p->uwProof[i]);
     }
 
-    int size = 0;
-
-    size += mclBnG1_serialize(buff, SIZE_G1, &p->piA);
+    size += mclBnG1_serialize(buff + size, SIZE_G1, &p->piA);
     size += mclBnG2_serialize(buff + size, SIZE_G2, &p->piB2);
     size += mclBnG1_serialize(buff + size, SIZE_G1, &p->piC);
 
@@ -450,18 +445,18 @@ proof read_proof()
     FILE *fproof;
     fproof = fopen("data/proof.params", "r");
 
-    p.uwProof = (mpz_t*) malloc((nPublic) * sizeof(mpz_t));
+    p.uwProof = (mclBnFr*) malloc((nPublic) * sizeof(mclBnFr));
+
+    int size = 0;
+
+    fread(buff, 1, (SIZE_FR * nPublic) + SIZE_G1 + SIZE_G2 + SIZE_G1, fproof);
 
     for (int i = 0; i < (nPublic); i++)
     {
-        mpz_init(p.uwProof[i]);
-        mpz_inp_raw(p.uwProof[i], fproof);
+        size += mclBnFr_deserialize(&p.uwProof[i], buff + size, SIZE_FR);
     }
 
-    int size = 0;
-
-    fread(buff, 1, SIZE_G1 + SIZE_G2 + SIZE_G1, fproof);
-    size += mclBnG1_deserialize(&p.piA, buff, SIZE_G1);
+    size += mclBnG1_deserialize(&p.piA, buff + size, SIZE_G1);
     size += mclBnG2_deserialize(&p.piB2, buff + size, SIZE_G2);
     size += mclBnG1_deserialize(&p.piC, buff + size, SIZE_G1);
 
diff --git a/src/zpie.h b/src/zpie.h
index aa5108b..f2e0a32 100644
--- a/src/zpie.h
+++ b/src/zpie.h
@@ -69,7 +69,7 @@ typedef struct
 
 typedef struct
 {
-    mpz_t *uwProof;
+    mclBnFr *uwProof;
     mclBnG1 piA, piC;
     mclBnG2 piB2;
 } proof;

From 0dede6bdc567665222a0812369e08d4a00ab3d38 Mon Sep 17 00:00:00 2001
From: xevisalle <xaviersalleras01@gmail.com>
Date: Tue, 14 Nov 2023 00:29:32 +0100
Subject: [PATCH 5/7] Switch to MCL

---
 circuits/utils.c     |  34 ++++++------
 src/common/utils.c   |  33 +----------
 src/gro16/gro16.h    |   6 +-
 src/gro16/parser.c   | 127 ++++++++++++++++++++-----------------------
 src/gro16/prover.c   |  57 +++++++------------
 src/gro16/verifier.c |   3 +-
 src/zpie.c           |  76 ++++++++++++--------------
 src/zpie.h           |   2 +-
 8 files changed, 139 insertions(+), 199 deletions(-)

diff --git a/circuits/utils.c b/circuits/utils.c
index 3c73630..62c02e3 100644
--- a/circuits/utils.c
+++ b/circuits/utils.c
@@ -19,19 +19,17 @@ void add(element uOut, element vOut, element u1, element v1, element u2, element
 
 	mul_constants(&factor, &one_int, &factor1, &d, &factor2);
 
-	mpz_t invFactor;
-	mpz_init(invFactor);
+	mclBnFr invFactor;
 
 	if(!setParams)
 	{
-		mpz_t f_check;
-		mpz_init(f_check);
-		mpz_add(f_check, uw[one.index], uw[factor.index]);
-		mpz_invert(invFactor, f_check, pPrime);
+		mclBnFr f_check;
+		mclBnFr_add(&f_check, &uw[one.index], &uw[factor.index]);
+		mclBnFr_inv(&invFactor, &f_check);
 	}
 
 	char buff[2048];
-  	mpz_get_str(buff, 10, invFactor);
+  	mclBnFr_getStr(buff, sizeof(buff), &invFactor, 10);
   	input(&factor4, buff);
 
 	addmul(&one, &factor, &one, &factor4); // verify x * 1/x = 1
@@ -47,13 +45,12 @@ void add(element uOut, element vOut, element u1, element v1, element u2, element
 
 	if(!setParams) 
 	{
-		mpz_t f_check;
-		mpz_init(f_check);
-		mpz_sub(f_check, uw[one.index], uw[factor.index]);
-		mpz_invert(invFactor, f_check, pPrime);
+		mclBnFr f_check;
+		mclBnFr_sub(&f_check, &uw[one.index], &uw[factor.index]);
+		mclBnFr_inv(&invFactor, &f_check);
 	}
 
-  	mpz_get_str(buff, 10, invFactor);
+  	mclBnFr_getStr(buff, sizeof(buff), &invFactor, 10);
   	input(&factor7, buff);
 
 	addmul_constants(&one, &one_int, &one, &one_neg, &factor, &one_int, &factor7); // verify x * 1/x = 1
@@ -146,7 +143,10 @@ void to_bits(element *bits, element val, int size)
 	{
 		if(!setParams)
 		{
-			mpz_tdiv_q_2exp(t1, uw[val.index], i);
+			mpz_t factor;
+			mpz_init(factor);
+			fr_to_mpz(&factor, &uw[val.index]);
+			mpz_tdiv_q_2exp(t1, factor, i);
 			mpz_and(t3, t1, t2);
 		}
 
@@ -156,11 +156,13 @@ void to_bits(element *bits, element val, int size)
 
 		mpz_ui_pow_ui(total, 2, i);
 
-		mpz_t one_mpz;
-		mpz_init_set_ui(one_mpz, 1);
+		mclBnFr one_mpz;
+		mclBnFr_setInt(&one_mpz, 1);
 
 		init(&b[i]);
-		mul_big_constants(&b[i], &total, &bits[i], &one_mpz, &one);
+		mclBnFr factor;
+		mpz_to_fr(&factor, &total);
+		mul_big_constants(&b[i], &factor, &bits[i], &one_mpz, &one);
 	}
 
 	element fa;
diff --git a/src/common/utils.c b/src/common/utils.c
index f7ce452..956b7c8 100644
--- a/src/common/utils.c
+++ b/src/common/utils.c
@@ -45,12 +45,12 @@ void init_setup(void *circuit)
     init_circuit(circuit);
     setParams = 0;
 
-    uw = (mpz_t*) malloc((M) * sizeof(mpz_t));
+    uw = (mclBnFr*) malloc((M) * sizeof(mclBnFr));
     LRO_constants = (mpz_t*) malloc((lro_const_total) * sizeof(mpz_t));
 
     for (int i = 0; i < M; i++)
     {
-       mpz_init2(uw[i], BITS);
+       mclBnFr_clear(&uw[i]);
     }
 }
 
@@ -240,35 +240,6 @@ void sort_list(mpz_t *exp[], int heapsize)
     elapsedSort += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
 }
 
-void bos_coster(mpz_t *exp[], int heapsize, int baseNum, proving_key *pk)
-{
-    sort_list(exp, heapsize);
-    while (mpz_cmp_ui(*exp[2], 0) != 0)
-    {
-        struct timespec begin, end;
-        clock_gettime(CLOCK_MONOTONIC, &begin);
-        mpz_sub(*exp[0], *exp[0], *exp[2]); 
-
-        if (baseNum) mclBnG1_add(&pk->xt1[exp[2]-wM], &pk->xt1[exp[0]-wM], &pk->xt1[exp[2]-wM]);
-        else
-        {
-            mclBnG1_add(&pk->A1[exp[2]-uw], &pk->A1[exp[0]-uw], &pk->A1[exp[2]-uw]);
-            mclBnG1_add(&pk->B1[exp[2]-uw], &pk->B1[exp[0]-uw], &pk->B1[exp[2]-uw]);
-            mclBnG2_add(&pk->B2[exp[2]-uw], &pk->B2[exp[0]-uw], &pk->B2[exp[2]-uw]);
-            mclBnG1_add(&pk->pk1[exp[2]-uw], &pk->pk1[exp[0]-uw], &pk->pk1[exp[2]-uw]);  
-        }
-
-        clock_gettime(CLOCK_MONOTONIC, &end);
-        elapsedBosCoster += (end.tv_sec - begin.tv_sec);
-        elapsedBosCoster += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
-        clock_gettime(CLOCK_MONOTONIC, &begin);
-        binarymaxheap(exp, 0, heapsize);
-        clock_gettime(CLOCK_MONOTONIC, &end);
-        elapsedSort += (end.tv_sec - begin.tv_sec);
-        elapsedSort += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
-    }
-}
-
 int fr_cmp(mclBnFr *frFactor1, mclBnFr *frFactor2)
 {
     mpz_t f1, f2;
diff --git a/src/gro16/gro16.h b/src/gro16/gro16.h
index 4b4c0d2..e0ecd94 100644
--- a/src/gro16/gro16.h
+++ b/src/gro16/gro16.h
@@ -95,11 +95,11 @@ struct Sigma2
 typedef struct
 {
     mpz_t Ne;
-    mclBnFr *wMFr;
+    mclBnFr *wM;
 
     int qap_size;
     int *LRO;
-    mpz_t *LRO_constants;
+    mclBnFr *LRO_constants;
 
     mclBnG1 alpha1;
     mclBnG1 beta1;
@@ -126,7 +126,7 @@ struct mulExpResult
 
 typedef struct
 {
-    mpz_t *constants;
+    mclBnFr *constants;
     mclBnGT alphabetaT;
     mclBnG2 gamma2;
     mclBnG2 delta2;
diff --git a/src/gro16/parser.c b/src/gro16/parser.c
index b4d18bc..ec1121f 100644
--- a/src/gro16/parser.c
+++ b/src/gro16/parser.c
@@ -1,7 +1,7 @@
 
 void element_log(char *text, element *oo)
 {
-	if(!setParams) gmp_printf("%s%Zd\n", text, uw[oo->index]);
+	//if(!setParams) gmp_printf("%s%Zd\n", text, uw[oo->index]);
 }
 
 void addmul(element *oo, element *lo1, element *lo2, element *ro)
@@ -9,9 +9,8 @@ void addmul(element *oo, element *lo1, element *lo2, element *ro)
 	if (setParams) N++;
 	else if (prover)
 	{
-		mpz_add(uw[oo->index], uw[lo1->index], uw[lo2->index]);
-		mpz_mul(uw[oo->index], uw[oo->index], uw[ro->index]);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
+		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
 	}
 	else
 	{
@@ -29,9 +28,8 @@ void addmul0(element *oo, element *lo1, element *lo2, element *ro)
 	if (setParams) N++;
 	else if (prover)
 	{
-		mpz_add(uw[oo->index], uw[lo1->index], uw[lo2->index]);
-		mpz_mul(uw[oo->index], uw[oo->index], uw[ro->index]);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
+		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
 	}
 	else
 	{
@@ -48,10 +46,9 @@ void add3mul(element *oo, element *lo1, element *lo2, element *lo3, element *ro)
 	if (setParams) N++;
 	else if (prover)
 	{
-		mpz_add(uw[oo->index], uw[lo1->index], uw[lo2->index]);
-		mpz_add(uw[oo->index], uw[oo->index], uw[lo3->index]);
-		mpz_mul(uw[oo->index], uw[oo->index], uw[ro->index]);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
+		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+		mclBnFr_add(&uw[oo->index], &uw[oo->index], &uw[lo3->index]);
+		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
 	}
 	else
 	{
@@ -72,12 +69,10 @@ void addsmul(element *oo, int *size, element *los, element *ro)
 	{
 		for (int i = 0; i < *size; i++)
 		{
-			mpz_add(uw[oo->index], uw[oo->index], uw[los[i].index]);
-			mpz_mod(uw[oo->index], uw[oo->index], pPrime);
+			mclBnFr_add(&uw[oo->index], &uw[oo->index], &uw[los[i].index]);
 		}
 
-		mpz_mul(uw[oo->index], uw[oo->index], uw[ro->index]);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
+		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
 	}
 	else
 	{
@@ -98,15 +93,12 @@ void add3muladd3(element *oo, element *lo1, element *lo2, element *lo3, element
 	if (setParams) N++;
 	else if (prover)
 	{
-		mpz_t factor;
-		mpz_init(factor);
-		mpz_add(uw[oo->index], uw[lo1->index], uw[lo2->index]);
-		mpz_add(uw[oo->index], uw[oo->index], uw[lo3->index]);
-		mpz_add(factor, uw[ro1->index], uw[ro2->index]);
-		mpz_add(factor, factor, uw[ro3->index]);
-		mpz_mul(uw[oo->index], uw[oo->index], factor);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
-		mpz_clear(factor);
+		mclBnFr factor;
+		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+		mclBnFr_add(&uw[oo->index], &uw[oo->index], &uw[lo3->index]);
+		mclBnFr_add(&factor, &uw[ro1->index], &uw[ro2->index]);
+		mclBnFr_add(&factor, &factor, &uw[ro3->index]);
+		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
 	}
 	else
 	{
@@ -127,13 +119,10 @@ void addmuladd(element *oo, element *lo1, element *lo2, element *ro1, element *r
 	if (setParams) N++;
 	else if (prover)
 	{
-		mpz_t factor;
-		mpz_init(factor);
-		mpz_add(uw[oo->index], uw[lo1->index], uw[lo2->index]);
-		mpz_add(factor, uw[ro1->index], uw[ro2->index]);
-		mpz_mul(uw[oo->index], factor, uw[oo->index]);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
-		mpz_clear(factor);
+		mclBnFr factor;
+		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+		mclBnFr_add(&factor, &uw[ro1->index], &uw[ro2->index]);
+		mclBnFr_mul(&uw[oo->index], &factor, &uw[oo->index]);
 	}
 	else
 	{
@@ -152,8 +141,7 @@ void mul(element *oo, element *lo, element *ro)
 	if (setParams) N++;
 	else if (prover)
 	{
-		mpz_mul(uw[oo->index], uw[lo->index], uw[ro->index]);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
+		mclBnFr_mul(&uw[oo->index], &uw[lo->index], &uw[ro->index]);
 	}
 	else
 	{
@@ -170,15 +158,15 @@ void addmul_constants(element *oo, int *lc1, element *lo1, int *lc2, element *lo
 	if (setParams) N++;
 	else if (prover)
 	{
-		mpz_t factor;
-		mpz_init(factor);
-		mpz_mul_si(factor, uw[lo1->index], *lc1);
-		mpz_mul_si(uw[oo->index], uw[lo2->index], *lc2);
-		mpz_add(factor, factor, uw[oo->index]);
-		mpz_mul_si(uw[oo->index], uw[ro->index], *rc);
-		mpz_mul(uw[oo->index], uw[oo->index], factor);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
-		mpz_clear(factor);
+		mclBnFr factor, factor2;
+		mclBnFr_setInt(&factor, *lc1);
+		mclBnFr_mul(&factor, &uw[lo1->index], &factor);
+		mclBnFr_setInt(&factor2, *lc2);
+		mclBnFr_mul(&uw[oo->index], &uw[lo2->index], &factor2);
+		mclBnFr_add(&factor, &factor, &uw[oo->index]);
+		mclBnFr_setInt(&factor2, *rc);
+		mclBnFr_mul(&uw[oo->index], &uw[ro->index], &factor2);
+		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
 	}
 	else
 	{
@@ -196,13 +184,12 @@ void mul_constants(element *oo, int *lc, element *lo, int *rc, element *ro)
 	if (setParams) N++;
 	else if (prover)
 	{
-		mpz_t factor;
-		mpz_init(factor);
-		mpz_mul_si(factor, uw[lo->index], *lc);
-		mpz_mul_si(uw[oo->index], uw[ro->index], *rc);
-		mpz_mul(uw[oo->index], uw[oo->index], factor);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
-		mpz_clear(factor);
+		mclBnFr factor, factor2;
+		mclBnFr_setInt(&factor, *lc);
+		mclBnFr_mul(&factor, &uw[lo->index], &factor);
+		mclBnFr_setInt(&factor2, *rc);
+		mclBnFr_mul(&uw[oo->index], &uw[ro->index], &factor2);
+		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
 	}
 	else
 	{
@@ -214,7 +201,7 @@ void mul_constants(element *oo, int *lc, element *lo, int *rc, element *ro)
 	}
 }
 
-void mul_big_constants(element *oo, mpz_t *lc, element *lo, mpz_t *rc, element *ro)
+void mul_big_constants(element *oo, mclBnFr *lc, element *lo, mclBnFr *rc, element *ro)
 {	
 	if (setParams) 
 	{
@@ -223,13 +210,10 @@ void mul_big_constants(element *oo, mpz_t *lc, element *lo, mpz_t *rc, element *
 	}
 	else if (prover)
 	{
-		mpz_t factor;
-		mpz_init(factor);
-		mpz_mul(factor, uw[lo->index], *lc);
-		mpz_mul(uw[oo->index], uw[ro->index], *rc);
-		mpz_mul(uw[oo->index], uw[oo->index], factor);
-		mpz_mod(uw[oo->index], uw[oo->index], pPrime);
-		mpz_clear(factor);
+		mclBnFr factor;
+		mclBnFr_mul(&factor, &uw[lo->index], lc);
+		mclBnFr_mul(&uw[oo->index], &uw[ro->index], rc);
+		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
 	}
 	else
 	{
@@ -238,8 +222,11 @@ void mul_big_constants(element *oo, mpz_t *lc, element *lo, mpz_t *rc, element *
 		O[cn][oo->index] = 1;
 
 		cn++;
-		mpz_init_set(LRO_constants[lro_constants_n], *lc);
-		mpz_init_set(LRO_constants[lro_constants_n + 1], *rc);
+		mpz_t factor;
+		fr_to_mpz(&factor, lc);
+		mpz_set(LRO_constants[lro_constants_n], factor);
+		fr_to_mpz(&factor, rc);
+		mpz_set(LRO_constants[lro_constants_n + 1], factor);
 		lro_constants_n += 2;
 	}
 }
@@ -256,7 +243,7 @@ void assert_equal(element *lo, element *ro)
 
 void input(element *var, char *val)
 {
-	if (!setParams) mpz_set_str(uw[var->index], val, 10);
+	if (!setParams) mclBnFr_setStr(&uw[var->index], val, strlen(val), 10);
 }
 
 void init_constant(element *toAdd, char *val)
@@ -266,7 +253,7 @@ void init_constant(element *toAdd, char *val)
 	{
 		toAdd->index = constant_n;
 		constant_n++;
-		mpz_set_str(uw[toAdd->index], val, 10);
+		mclBnFr_setStr(&uw[toAdd->index], val, strlen(val), 10);
 	}
 	if (setParams) nConst++;
 }
@@ -343,7 +330,7 @@ void test_full_api()
 
 void test_constraint_system(void)
 {
-	uw = (mpz_t*) malloc((99) * sizeof(mpz_t));
+	uw = (mclBnFr*) malloc((99) * sizeof(mclBnFr));
 	wn = nPublic + nConst;
 	un = nConst;
 	constant_n = 0;
@@ -352,15 +339,21 @@ void test_constraint_system(void)
 
     for (int i = 0; i < 99; i++)
     {
-        mpz_init2(uw[i], BITS);
+        mclBnFr_clear(&uw[i]);
     }
 
 	prover = 1;
 	init_circuit(&test_full_api);
 	prover = 0;
 
-	CU_ASSERT(mpz_cmp_ui(uw[nConst], 50) == 0);
-	CU_ASSERT(mpz_cmp_ui(uw[1+nConst], 150) == 0);
-	CU_ASSERT(mpz_cmp_ui(uw[2+nConst], 150) == 0);
-	CU_ASSERT(mpz_cmp_ui(uw[3+nConst], 200) == 0);
+	mclBnFr equal;
+	mclBnFr_setInt(&equal, 50);
+	CU_ASSERT(mclBnFr_isEqual(&uw[nConst], &equal));
+
+	mclBnFr_setInt(&equal, 150);
+	CU_ASSERT(mclBnFr_isEqual(&uw[1+nConst], &equal));
+	CU_ASSERT(mclBnFr_isEqual(&uw[2+nConst], &equal));
+
+	mclBnFr_setInt(&equal, 200);
+	CU_ASSERT(mclBnFr_isEqual(&uw[3+nConst], &equal));
 }
\ No newline at end of file
diff --git a/src/gro16/prover.c b/src/gro16/prover.c
index e62d4ac..39d0c66 100644
--- a/src/gro16/prover.c
+++ b/src/gro16/prover.c
@@ -2,13 +2,6 @@
 void h_coefficients(proving_key *pk)
 {
     int n = mpz_get_ui(pk->Ne);
-    mclBnFr uwFr[M];
-
-    #pragma omp parallel for
-    for (int j = 0; j < M; j++)
-    {
-        mpz_to_fr(&uwFr[j], &uw[j]);
-    }
 
     #pragma omp parallel for
     for (int j = 0; j < n; j++)
@@ -25,21 +18,20 @@ void h_coefficients(proving_key *pk)
     {
         switch (pk->LRO[j])
         {
-            case 1: mclBnFr_add(&AsFr[pk->LRO[j+1]], &AsFr[pk->LRO[j+1]], &uwFr[pk->LRO[j+2]]); break;
-            case 2: mclBnFr_add(&BsFr[pk->LRO[j+1]], &BsFr[pk->LRO[j+1]], &uwFr[pk->LRO[j+2]]); break;
-            case 3: mclBnFr_add(&CsFr[pk->LRO[j+1]], &CsFr[pk->LRO[j+1]], &uwFr[pk->LRO[j+2]]); break;
+            case 1: mclBnFr_add(&AsFr[pk->LRO[j+1]], &AsFr[pk->LRO[j+1]], &uw[pk->LRO[j+2]]); break;
+            case 2: mclBnFr_add(&BsFr[pk->LRO[j+1]], &BsFr[pk->LRO[j+1]], &uw[pk->LRO[j+2]]); break;
+            case 3: mclBnFr_add(&CsFr[pk->LRO[j+1]], &CsFr[pk->LRO[j+1]], &uw[pk->LRO[j+2]]); break;
             case 10:
             {
                 mclBnFr factorFr;
                 if (pk->LRO[j+3] != INT_MAX)
                 {
                     mclBnFr_setInt(&factorFr, pk->LRO[j+3]);
-                    mclBnFr_mul(&factorFr, &uwFr[pk->LRO[j+2]], &factorFr);
+                    mclBnFr_mul(&factorFr, &uw[pk->LRO[j+2]], &factorFr);
                 }
                 else
                 {
-                    mpz_to_fr(&factorFr, &pk->LRO_constants[l_it]);
-                    mclBnFr_mul(&factorFr, &uwFr[pk->LRO[j+2]], &factorFr);
+                    mclBnFr_mul(&factorFr, &uw[pk->LRO[j+2]], &pk->LRO_constants[l_it]);
                     l_it+=2;
                 }
                 mclBnFr_add(&AsFr[pk->LRO[j+1]], &AsFr[pk->LRO[j+1]], &factorFr); 
@@ -52,12 +44,11 @@ void h_coefficients(proving_key *pk)
                 if (pk->LRO[j+3] != INT_MAX)
                 {
                     mclBnFr_setInt(&factorFr, pk->LRO[j+3]);
-                    mclBnFr_mul(&factorFr, &uwFr[pk->LRO[j+2]], &factorFr);
+                    mclBnFr_mul(&factorFr, &uw[pk->LRO[j+2]], &factorFr);
                 }
                 else
                 {
-                    mpz_to_fr(&factorFr, &pk->LRO_constants[r_it]);
-                    mclBnFr_mul(&factorFr, &uwFr[pk->LRO[j+2]], &factorFr);
+                    mclBnFr_mul(&factorFr, &uw[pk->LRO[j+2]], &pk->LRO_constants[r_it]);
                     r_it+=2;
                 }
                 mclBnFr_add(&BsFr[pk->LRO[j+1]], &BsFr[pk->LRO[j+1]], &factorFr);
@@ -71,13 +62,13 @@ void h_coefficients(proving_key *pk)
     {
         switch (get_thread())
         {
-            case 0: ifft_t(n, pk->wMFr, AsFr); break;
-            case 1: ifft_t(n, pk->wMFr, BsFr); break;
-            case 2: ifft_t(n, pk->wMFr, CsFr); break;
+            case 0: ifft_t(n, pk->wM, AsFr); break;
+            case 1: ifft_t(n, pk->wM, BsFr); break;
+            case 2: ifft_t(n, pk->wM, CsFr); break;
             case 99:
-                ifft_t(n, pk->wMFr, AsFr);
-                ifft_t(n, pk->wMFr, BsFr);
-                ifft_t(n, pk->wMFr, CsFr);
+                ifft_t(n, pk->wM, AsFr);
+                ifft_t(n, pk->wM, BsFr);
+                ifft_t(n, pk->wM, CsFr);
                 break;
         }
     }
@@ -89,26 +80,16 @@ void h_coefficients(proving_key *pk)
         mclBnFr_sub(&AsFr[i], &AsFr[i], &CsFr[i]);
     }
 
-    ifft(n, pk->wMFr, AsFr);
+    ifft(n, pk->wM, AsFr);
 }
 
 void mul_exp(struct mulExpResult *result, mclBnFr *uwProof, proving_key *pk)
 {
     int n = mpz_get_ui(pk->Ne);
 
-    mclBnFr uwFactor[M];
-    mclBnFr uwFactorPublic[M-(nPublic + nConst)];
-
     for (int i = nConst; i < (nPublic + nConst); i++)
     {
-        mpz_to_fr(&uwProof[i-nConst], &uw[i]);
-    }
-
-    #pragma omp parallel for
-    for (int i = 0; i < M; i++)
-    {
-        mpz_to_fr(&uwFactor[i], &uw[i]);
-        if(i >= (nPublic + nConst)) mpz_to_fr(&uwFactorPublic[i-(nPublic + nConst)], &uw[i]);
+        uwProof[i-nConst] = uw[i];
     }
 
     #ifdef IS_MAC_OS
@@ -117,10 +98,10 @@ void mul_exp(struct mulExpResult *result, mclBnFr *uwProof, proving_key *pk)
         int num_threads = get_nprocs();
     #endif
 
-    mclBnG1_mulVecMT(&result->uwA1, pk->A1, uwFactor, M, num_threads);
-    mclBnG1_mulVecMT(&result->uwB1, pk->B1, uwFactor, M, num_threads);
-    mclBnG2_mulVecMT(&result->uwB2, pk->B2, uwFactor, M, num_threads);
-    mclBnG1_mulVecMT(&result->uwC1, pk->pk1, uwFactorPublic, M-(nPublic + nConst), num_threads);
+    mclBnG1_mulVecMT(&result->uwA1, pk->A1, uw, M, num_threads);
+    mclBnG1_mulVecMT(&result->uwB1, pk->B1, uw, M, num_threads);
+    mclBnG2_mulVecMT(&result->uwB2, pk->B2, uw, M, num_threads);
+    mclBnG1_mulVecMT(&result->uwC1, pk->pk1, uw + nPublic + nConst, M-(nPublic + nConst), num_threads);
     mclBnG1_mulVecMT(&result->htdelta, pk->xt1_rand, AsFr, n, num_threads);
 }
 
diff --git a/src/gro16/verifier.c b/src/gro16/verifier.c
index 3aec82c..017f122 100644
--- a/src/gro16/verifier.c
+++ b/src/gro16/verifier.c
@@ -17,8 +17,7 @@ int verify(proof *p, verifying_key *vk)
     for (int i = (nConst); i--;)
     {
         // Vu = Vu + u[i] * s1.vk[i]
-        mpz_to_fr(&frFactor, &vk->constants[i]);
-        mclBnG1_mul(&factorG1, &vk->vk1[i], &frFactor);
+        mclBnG1_mul(&factorG1, &vk->vk1[i], &vk->constants[i]);
         mclBnG1_add(&Vu, &Vu, &factorG1);
     }
 
diff --git a/src/zpie.c b/src/zpie.c
index bf69cb2..088580f 100644
--- a/src/zpie.c
+++ b/src/zpie.c
@@ -37,8 +37,8 @@ setup_keys perform_setup(void *circuit)
     setup_keys keys;
     mpz_init_set(keys.pk.Ne, Ne);
 
-    keys.pk.LRO_constants = (mpz_t*) malloc((lro_const_total) * sizeof(mpz_t));
-    keys.pk.wMFr = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
+    keys.pk.LRO_constants = (mclBnFr*) malloc((lro_const_total) * sizeof(mclBnFr));
+    keys.pk.wM = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
     keys.vk.vk1 = (mclBnG1*) malloc(((nPublic + nConst)) * sizeof(mclBnG1));
 
     wM = (mpz_t*) malloc((n) * sizeof(mpz_t));
@@ -53,7 +53,7 @@ setup_keys perform_setup(void *circuit)
     {
         mpz_init(wM[i]);
         mpz_powm_ui(wM[i], w, i, pPrime);
-        mpz_to_fr(&keys.pk.wMFr[i], &wM[i]);
+        mpz_to_fr(&keys.pk.wM[i], &wM[i]);
     }
 
     struct timespec begin, end;
@@ -66,7 +66,7 @@ setup_keys perform_setup(void *circuit)
 
     for (int i = 0; i < lro_const_total; i++)
     {
-        mpz_init_set(keys.pk.LRO_constants[i], LRO_constants[i]);
+        mpz_to_fr(&keys.pk.LRO_constants[i], &LRO_constants[i]);
     }
 
     int it = 0;
@@ -135,12 +135,12 @@ setup_keys perform_setup(void *circuit)
     keys.vk.gamma2 = s2.gamma;
     keys.vk.delta2 = s2.delta;
 
-    keys.vk.constants = (mpz_t*) malloc((nConst) * sizeof(mpz_t));
+    keys.vk.constants = (mclBnFr*) malloc((nConst) * sizeof(mclBnFr));
 
     for (int i = 0; i < (nConst); i++)
     {
-        mpz_init(keys.vk.constants[i]);
-        mpz_set(keys.vk.constants[i], uw[i]);
+        mclBnFr_neg(&keys.vk.constants[i], &uw[i]);
+        mclBnFr_neg(&keys.vk.constants[i], &keys.vk.constants[i]);
     }
 
     for (int i = 0; i < (nPublic + nConst); i++)
@@ -165,7 +165,7 @@ void serialize_pk(proving_key *pk)
 
     int n = mpz_get_ui(pk->Ne);
 
-    int buff_pk_size = SIZE_FR * n + SIZE_G2 * (2 + M) + SIZE_G1 * (M - (nPublic + nConst) + 3 + n + 2 * M);
+    int buff_pk_size = SIZE_FR * (n + lro_const_total) + SIZE_G2 * (2 + M) + SIZE_G1 * (M - (nPublic + nConst) + 3 + n + 2 * M);
     char buff_pk[buff_pk_size];
 
     mpz_out_raw(fpk, pk->Ne);
@@ -181,16 +181,16 @@ void serialize_pk(proving_key *pk)
         mpz_out_raw(fpk, factor);
     }
 
+    int size = 0;
+
     for (int i = 0; i < lro_const_total; i++)
     {
-        mpz_out_raw(fpk, pk->LRO_constants[i]);
+        size += mclBnFr_serialize(buff_pk + size, SIZE_FR, &pk->LRO_constants[i]);
     }
 
-    int size = 0;
-
     for (int i = 0; i < n; i++)
     {
-        size += mclBnFr_serialize(buff_pk + size, SIZE_FR, &pk->wMFr[i]);
+        size += mclBnFr_serialize(buff_pk + size, SIZE_FR, &pk->wM[i]);
     }
 
     size += mclBnG1_serialize(buff_pk + size, SIZE_G1, &pk->alpha1);
@@ -225,17 +225,17 @@ void serialize_vk(verifying_key *vk)
     FILE *fvk;
     fvk = fopen("data/verifyingkey.params", "w");
 
-    int buff_vk_size = SIZE_GT + SIZE_G2 * 2 + SIZE_G1 * (nPublic + nConst);
+    int buff_vk_size = SIZE_GT + SIZE_G2 * 2 + SIZE_G1 * (nPublic + nConst) + SIZE_FR * nConst;
     char buff_vk[buff_vk_size];
 
+    int size = 0;
+
     for (int i = 0; i < nConst; i++)
     {
-        mpz_out_raw(fvk, vk->constants[i]);
+        size += mclBnFr_serialize(buff_vk + size, SIZE_FR, &vk->constants[i]);
     }
-
-    int size = 0;
-
-    size += mclBnGT_serialize(buff_vk, SIZE_GT, &vk->alphabetaT);
+    
+    size += mclBnGT_serialize(buff_vk + size, SIZE_GT, &vk->alphabetaT);
     size += mclBnG2_serialize(buff_vk + size, SIZE_G2, &vk->gamma2);
     size += mclBnG2_serialize(buff_vk + size, SIZE_G2, &vk->delta2);
 
@@ -273,12 +273,12 @@ setup_keys read_setup(void *circuit)
 
     int n = mpz_get_ui(keys.pk.Ne);
 
-    int buff_pk_size = SIZE_FR * n + SIZE_G2 * (2 + M) + SIZE_G1 * (M - (nPublic + nConst) + 3 + n + 2 * M);
+    int buff_pk_size = SIZE_FR * (n + lro_const_total) + SIZE_G2 * (2 + M) + SIZE_G1 * (M - (nPublic + nConst) + 3 + n + 2 * M);
     char buff_pk[buff_pk_size];
     
-    keys.pk.wMFr = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
+    keys.pk.wM = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
     keys.vk.vk1 = (mclBnG1*) malloc(((nPublic + nConst)) * sizeof(mclBnG1));
-    keys.vk.constants = (mpz_t*) malloc(((nConst)) * sizeof(mpz_t));
+    keys.vk.constants = (mclBnFr*) malloc(((nConst)) * sizeof(mclBnFr));
 
     keys.pk.xt1 = (mclBnG1*) malloc((n) * sizeof(mclBnG1));
     keys.pk.xt1_rand = (mclBnG1*) malloc((n) * sizeof(mclBnG1));
@@ -286,7 +286,7 @@ setup_keys read_setup(void *circuit)
     keys.pk.B1 = (mclBnG1*) malloc((M) * sizeof(mclBnG1));
     keys.pk.pk1 = (mclBnG1*) malloc((M-(nPublic + nConst)) * sizeof(mclBnG1));
     keys.pk.B2 = (mclBnG2*) malloc((M) * sizeof(mclBnG2));
-    keys.pk.LRO_constants = (mpz_t*) malloc((lro_const_total) * sizeof(mpz_t));
+    keys.pk.LRO_constants = (mclBnFr*) malloc((lro_const_total) * sizeof(mclBnFr));
 
     mpz_t factor;
     mpz_init(factor);
@@ -301,18 +301,17 @@ setup_keys read_setup(void *circuit)
         keys.pk.LRO[i] = mpz_get_si(factor);
     }
 
+    int size = 0;
+    fread(buff_pk, 1, buff_pk_size, fpk);
+
     for (int i = 0; i < lro_const_total; i++)
     {
-        mpz_init(keys.pk.LRO_constants[i]);
-        mpz_inp_raw(keys.pk.LRO_constants[i], fpk);
+        size += mclBnFr_deserialize(&keys.pk.LRO_constants[i], buff_pk + size, SIZE_FR);
     }
 
-    int size = 0;
-    fread(buff_pk, 1, buff_pk_size, fpk);
-
     for (int i = 0; i < n; i++)
     {
-        size += mclBnFr_deserialize(&keys.pk.wMFr[i], buff_pk + size, SIZE_FR);
+        size += mclBnFr_deserialize(&keys.pk.wM[i], buff_pk + size, SIZE_FR);
     }
         
     size += mclBnG1_deserialize(&keys.pk.alpha1, buff_pk + size, SIZE_G1);
@@ -337,18 +336,18 @@ setup_keys read_setup(void *circuit)
     {
         size += mclBnG1_deserialize(&keys.pk.xt1[i], buff_pk + size, SIZE_G1);
     }
+    
+    char buff_vk[SIZE_GT + SIZE_G2 * 2 + SIZE_G1 * (nPublic + nConst) + SIZE_FR * nConst];
+    size = 0;
+
+    fread(buff_vk, 1, SIZE_GT + SIZE_G2 * 2 + SIZE_G1 * (nPublic + nConst) + SIZE_FR * nConst, fvk);
 
     for (int i = 0; i < nConst; i++)
     {
-        mpz_init(keys.vk.constants[i]);
-        mpz_inp_raw(keys.vk.constants[i], fvk);
+        size += mclBnFr_deserialize(&keys.vk.constants[i], buff_vk + size, SIZE_FR);
     }
-    
-    char buff_vk[SIZE_GT + SIZE_G2 * 2 + SIZE_G1 * (nPublic + nConst)];
-    size = 0;
 
-    fread(buff_vk, 1, SIZE_GT + SIZE_G2 * 2 + SIZE_G1 * (nPublic + nConst), fvk);
-    size += mclBnGT_deserialize(&keys.vk.alphabetaT, buff_vk, SIZE_GT);
+    size += mclBnGT_deserialize(&keys.vk.alphabetaT, buff_vk + size, SIZE_GT);
     size += mclBnG2_deserialize(&keys.vk.gamma2, buff_vk + size, SIZE_G2);
     size += mclBnG2_deserialize(&keys.vk.delta2, buff_vk + size, SIZE_G2);
 
@@ -374,7 +373,7 @@ proof generate_proof(void *circuit, proving_key *pk)
     constant_n = 0;
     for (int i = 0; i < M; i++)
     {
-        mpz_init(uw[i]);
+        mclBnFr_clear(&uw[i]);
     }
 
     int n = mpz_get_ui(pk->Ne);
@@ -408,11 +407,6 @@ proof generate_proof(void *circuit, proving_key *pk)
         mclBnFr_clear(&rsigmaInv[i]);
     }
 
-    for (int i = 0; i < M; i++)
-    {
-        mpz_clear(uw[i]);
-    }
-
     return p;
 }
 
diff --git a/src/zpie.h b/src/zpie.h
index f2e0a32..3133fbe 100644
--- a/src/zpie.h
+++ b/src/zpie.h
@@ -57,7 +57,7 @@ int nPublic;
 int nConst;
 int setParams;
 
-mpz_t *uw;
+mclBnFr *uw;
 
 typedef struct
 {

From c3f568fe9451c295196234544a98f4c108debdde Mon Sep 17 00:00:00 2001
From: xevisalle <xavier@dusk.network>
Date: Wed, 3 Dec 2025 20:04:48 +0100
Subject: [PATCH 6/7] Fix compilation

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 3655131..e703084 100644
--- a/Makefile
+++ b/Makefile
@@ -6,7 +6,7 @@ CARM = arm-linux-gnueabihf-gcc
 COMMON = src/$(MAIN).c -o $(OUT) -std=gnu99 -Ofast -Wno-unused-result -Wno-pointer-sign
 MCLPATH = ../mcl
 GMPPATH = /usr/local
-LIB = $(MCLPATH)/lib/libmclbn384_256.a $(MCLPATH)/lib/libmcl.a -I $(MCLPATH)/include -lgmp -lcunit -lm -lstdc++
+LIB = $(MCLPATH)/lib/lishe384_256.a $(MCLPATH)/lib/libmcl.a -I $(MCLPATH)/include -lgmp -lcunit -lm -lstdc++
 LIBMAC = /opt/homebrew/lib/libgmp.a /opt/homebrew/opt/libomp/lib/libomp.a /opt/homebrew/opt/cunit/lib/libcunit.a $(MCLPATH)/lib/libmclbn384_256.a $(MCLPATH)/lib/libmcl.a -I /opt/homebrew/opt/libomp/include -I /opt/homebrew/include -I $(MCLPATH)/include -lm -lstdc++
 LIBCROSS = $(MCLPATH)/lib/libmclbn384_256.a $(MCLPATH)/lib/libmcl.a $(GMPPATH)/lib/libgmp.a -I $(MCLPATH)/include -I $(GMPPATH)/include -lstdc++
 SRC = $(shell pwd)/src/*.c $(shell pwd)/circuits/*.c $(shell pwd)/src/*.h

From 807f6ac3dbe4987be876814e7bcbb38a018a4ff7 Mon Sep 17 00:00:00 2001
From: xevisalle <xavier@dusk.network>
Date: Wed, 3 Dec 2025 20:43:38 +0100
Subject: [PATCH 7/7] Format project

---
 .clang-format                   |  17 +
 circuits/eddsa.c                |  76 ++---
 circuits/mimc.c                 |  72 ++--
 circuits/utils.c                | 339 +++++++++----------
 src/bench.c                     |  43 +--
 src/bulletproofs/bulletproofs.c | 200 +++++------
 src/common/fourier.c            |  23 +-
 src/common/sha256.c             | 251 +++++++-------
 src/common/sha256.h             |  37 ++-
 src/common/utils.c              | 144 ++++----
 src/gro16/gro16.h               |  90 ++---
 src/gro16/parser.c              | 571 ++++++++++++++++----------------
 src/gro16/prover.c              | 137 ++++----
 src/gro16/qap.c                 |  54 +--
 src/gro16/setup.c               |  33 +-
 src/gro16/verifier.c            |  43 ++-
 src/tests.c                     |  58 ++--
 src/zpie.c                      | 107 +++---
 src/zpie.h                      | 122 ++++---
 19 files changed, 1285 insertions(+), 1132 deletions(-)
 create mode 100644 .clang-format

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..b7bca01
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,17 @@
+BasedOnStyle: LLVM
+
+IndentWidth: 4
+TabWidth: 4
+UseTab: Never
+
+ColumnLimit: 100
+BreakBeforeBraces: Allman
+PointerAlignment: Left
+
+SpaceAfterCStyleCast: true
+SpacesInParentheses: false
+SpaceBeforeParens: ControlStatements
+
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
diff --git a/circuits/eddsa.c b/circuits/eddsa.c
index 8726c20..38f8224 100644
--- a/circuits/eddsa.c
+++ b/circuits/eddsa.c
@@ -3,58 +3,58 @@
 #include "mimc.c"
 #include "utils.c"
 
-void verify_eddsa(eddsa_signature edsig, point B, point A, char *msg)
+void verify_eddsa(eddsa_signature edsig, point B, point A, char* msg)
 {
-	element out[4];
+    element out[4];
 
-	for (int i = 0; i < 4; ++i)
-	{
-		init(&out[i]);
-	}
+    for (int i = 0; i < 4; ++i)
+    {
+        init(&out[i]);
+    }
 
-	element outPrivate[3];
-	init_array(outPrivate, 3);
+    element outPrivate[3];
+    init_array(outPrivate, 3);
 
-	element Bx, By;
-	init(&Bx);
-	init(&By);
+    element Bx, By;
+    init(&Bx);
+    init(&By);
 
-	input(&Bx, B.x);
-	input(&By, B.y);
+    input(&Bx, B.x);
+    input(&By, B.y);
 
-	int arraySize = 5;
-	element ram[arraySize];
-	init_array(ram, arraySize);
-	
-	input(&ram[0], edsig.R.x); 
-	input(&ram[1], edsig.R.y);
-	input(&ram[2], A.x);
-	input(&ram[3], A.y);
-	input(&ram[4], msg);
+    int arraySize = 5;
+    element ram[arraySize];
+    init_array(ram, arraySize);
 
-	element signature;
-	init(&signature);
-	input(&signature, edsig.S);
+    input(&ram[0], edsig.R.x);
+    input(&ram[1], edsig.R.y);
+    input(&ram[2], A.x);
+    input(&ram[3], A.y);
+    input(&ram[4], msg);
 
-	multi_hash(outPrivate[0], ram, 5);
+    element signature;
+    init(&signature);
+    input(&signature, edsig.S);
 
-	int size = 254;
-	element hBits[size];
-	element sBits[size];
+    multi_hash(outPrivate[0], ram, 5);
 
-	init_array(hBits, size);
-	init_array(sBits, size);
+    int size = 254;
+    element hBits[size];
+    element sBits[size];
 
-	to_bits(hBits, outPrivate[0], size);
-	to_bits(sBits, signature, size-1);
+    init_array(hBits, size);
+    init_array(sBits, size);
 
-	mul_scalar(outPrivate[1], outPrivate[2], ram[2], ram[3], hBits, size);
-	add(out[0], out[1], outPrivate[1], outPrivate[2], ram[0], ram[1]);
+    to_bits(hBits, outPrivate[0], size);
+    to_bits(sBits, signature, size - 1);
 
-	mul_scalar(out[2], out[3], Bx, By, sBits, size-1);
+    mul_scalar(outPrivate[1], outPrivate[2], ram[2], ram[3], hBits, size);
+    add(out[0], out[1], outPrivate[1], outPrivate[2], ram[0], ram[1]);
 
-	assert_equal(&out[2], &out[0]);
-	assert_equal(&out[3], &out[1]);
+    mul_scalar(out[2], out[3], Bx, By, sBits, size - 1);
+
+    assert_equal(&out[2], &out[0]);
+    assert_equal(&out[3], &out[1]);
 }
 
 #endif
\ No newline at end of file
diff --git a/circuits/mimc.c b/circuits/mimc.c
index a81df29..9b13673 100644
--- a/circuits/mimc.c
+++ b/circuits/mimc.c
@@ -3,50 +3,54 @@
 
 #define NROUNDS 91
 
-void mimc7(element *h, element *x_in, element *k)
+void mimc7(element* h, element* x_in, element* k)
 {
-	element r[NROUNDS];
-	element f[NROUNDS*3];
+    element r[NROUNDS];
+    element f[NROUNDS * 3];
 
-	init_array(r, NROUNDS);
-	init_array(f, NROUNDS*3);
+    init_array(r, NROUNDS);
+    init_array(f, NROUNDS * 3);
 
-	int it = 0;
+    int it = 0;
 
-	for (int i = 0; i < NROUNDS; i++)
-	{
-		if (i == 0) addmuladd(&f[it], k, x_in, k, x_in);
-		else add3muladd3(&f[it], k, &r[i-1], &c_mimc[i], k, &r[i-1], &c_mimc[i]);
+    for (int i = 0; i < NROUNDS; i++)
+    {
+        if (i == 0)
+            addmuladd(&f[it], k, x_in, k, x_in);
+        else
+            add3muladd3(&f[it], k, &r[i - 1], &c_mimc[i], k, &r[i - 1], &c_mimc[i]);
 
-		mul(&f[it+1], &f[it], &f[it]);
-		mul(&f[it+2], &f[it+1], &f[it]);
-		if (i == 0) addmul(&r[i], k, x_in, &f[it+2]);
-		else add3mul(&r[i], k, &r[i-1], &c_mimc[i], &f[it+2]);
+        mul(&f[it + 1], &f[it], &f[it]);
+        mul(&f[it + 2], &f[it + 1], &f[it]);
+        if (i == 0)
+            addmul(&r[i], k, x_in, &f[it + 2]);
+        else
+            add3mul(&r[i], k, &r[i - 1], &c_mimc[i], &f[it + 2]);
 
-		it = it + 3;
-	}
+        it = it + 3;
+    }
 
-	addmul(h, k, &r[NROUNDS-1], &one);
+    addmul(h, k, &r[NROUNDS - 1], &one);
 }
 
-void multi_hash(element h, element *x_in, int arraySize)
+void multi_hash(element h, element* x_in, int arraySize)
 {
-	element k[arraySize];
-	init_array(k, arraySize);
-	input(&k[0], "0");
-
-	for (int i = 0; i < arraySize-1; i++)
-	{
-		element hf;
-		init(&hf);
-		mimc7(&hf, &x_in[i], &k[i]);
-		add3mul(&k[i+1], &x_in[i], &k[i], &hf, &one);
-	}
-
-	element hf;
-	init(&hf);
-	mimc7(&hf, &x_in[arraySize-1], &k[arraySize-1]);
-	add3mul(&h, &x_in[arraySize-1], &k[arraySize-1], &hf, &one);
+    element k[arraySize];
+    init_array(k, arraySize);
+    input(&k[0], "0");
+
+    for (int i = 0; i < arraySize - 1; i++)
+    {
+        element hf;
+        init(&hf);
+        mimc7(&hf, &x_in[i], &k[i]);
+        add3mul(&k[i + 1], &x_in[i], &k[i], &hf, &one);
+    }
+
+    element hf;
+    init(&hf);
+    mimc7(&hf, &x_in[arraySize - 1], &k[arraySize - 1]);
+    add3mul(&h, &x_in[arraySize - 1], &k[arraySize - 1], &hf, &one);
 }
 
 #endif
\ No newline at end of file
diff --git a/circuits/utils.c b/circuits/utils.c
index 62c02e3..ad7bbd7 100644
--- a/circuits/utils.c
+++ b/circuits/utils.c
@@ -1,185 +1,188 @@
 void add(element uOut, element vOut, element u1, element v1, element u2, element v2)
 {
-	element factor, factor1, factor2, factor3, factor4, factor5, factor6, factor7;
-	init(&factor);
-	init(&factor1);
-	init(&factor2);
-	init(&factor3);
-	init(&factor4);
-	init(&factor5);
-	init(&factor6);
-	init(&factor7);
-
-	// uOut = (u1*v2 + v1*u2) / (1 + d*u1*u2*v1*v2)
-	mul(&factor1, &u1, &v2);
-	mul(&factor2, &v1, &u2);
-
-	int d = 168696;
-	int one_int = 1;
-
-	mul_constants(&factor, &one_int, &factor1, &d, &factor2);
-
-	mclBnFr invFactor;
-
-	if(!setParams)
-	{
-		mclBnFr f_check;
-		mclBnFr_add(&f_check, &uw[one.index], &uw[factor.index]);
-		mclBnFr_inv(&invFactor, &f_check);
-	}
-
-	char buff[2048];
-  	mclBnFr_getStr(buff, sizeof(buff), &invFactor, 10);
-  	input(&factor4, buff);
-
-	addmul(&one, &factor, &one, &factor4); // verify x * 1/x = 1
-  	addmul(&uOut, &factor1, &factor2, &factor4);
-
-	// vOut = (v1*v2 - a*u1*u2) / (1 - d*u1*u2*v1*v2)
-	mul(&factor5, &v1, &v2);
-	
-	int a = -168700;
-	int one_neg = -1;
-
-	mul_constants(&factor6, &a, &u1, &one_int, &u2);
-
-	if(!setParams) 
-	{
-		mclBnFr f_check;
-		mclBnFr_sub(&f_check, &uw[one.index], &uw[factor.index]);
-		mclBnFr_inv(&invFactor, &f_check);
-	}
-
-  	mclBnFr_getStr(buff, sizeof(buff), &invFactor, 10);
-  	input(&factor7, buff);
-
-	addmul_constants(&one, &one_int, &one, &one_neg, &factor, &one_int, &factor7); // verify x * 1/x = 1
-  	addmul(&vOut, &factor5, &factor6, &factor7);
+    element factor, factor1, factor2, factor3, factor4, factor5, factor6, factor7;
+    init(&factor);
+    init(&factor1);
+    init(&factor2);
+    init(&factor3);
+    init(&factor4);
+    init(&factor5);
+    init(&factor6);
+    init(&factor7);
+
+    // uOut = (u1*v2 + v1*u2) / (1 + d*u1*u2*v1*v2)
+    mul(&factor1, &u1, &v2);
+    mul(&factor2, &v1, &u2);
+
+    int d = 168696;
+    int one_int = 1;
+
+    mul_constants(&factor, &one_int, &factor1, &d, &factor2);
+
+    mclBnFr invFactor;
+
+    if (!setParams)
+    {
+        mclBnFr f_check;
+        mclBnFr_add(&f_check, &uw[one.index], &uw[factor.index]);
+        mclBnFr_inv(&invFactor, &f_check);
+    }
+
+    char buff[2048];
+    mclBnFr_getStr(buff, sizeof(buff), &invFactor, 10);
+    input(&factor4, buff);
+
+    addmul(&one, &factor, &one, &factor4); // verify x * 1/x = 1
+    addmul(&uOut, &factor1, &factor2, &factor4);
+
+    // vOut = (v1*v2 - a*u1*u2) / (1 - d*u1*u2*v1*v2)
+    mul(&factor5, &v1, &v2);
+
+    int a = -168700;
+    int one_neg = -1;
+
+    mul_constants(&factor6, &a, &u1, &one_int, &u2);
+
+    if (!setParams)
+    {
+        mclBnFr f_check;
+        mclBnFr_sub(&f_check, &uw[one.index], &uw[factor.index]);
+        mclBnFr_inv(&invFactor, &f_check);
+    }
+
+    mclBnFr_getStr(buff, sizeof(buff), &invFactor, 10);
+    input(&factor7, buff);
+
+    addmul_constants(&one, &one_int, &one, &one_neg, &factor, &one_int,
+                     &factor7); // verify x * 1/x = 1
+    addmul(&vOut, &factor5, &factor6, &factor7);
 }
 
-void mul_scalar(element mulOut1, element mulOut2, element A1, element A2, element *bits, int size)
+void mul_scalar(element mulOut1, element mulOut2, element A1, element A2, element* bits, int size)
 {
-	element accumulatedP1[size+1];
-	element accumulatedP2[size+1];
-
-	element step1[size+1];
-	element step2[size+1];
-
-	element doubledP1[size];
-	element doubledP2[size];
-
-	element oneNeg;
-	init(&oneNeg);
-	input(&oneNeg, "-1");
-
-	init_array(doubledP1, size);
-	init_array(doubledP2, size);
-
-	init_array(accumulatedP1, size+1);
-	init_array(accumulatedP2, size+1);
-	init_array(step1, size+1);
-	init_array(step2, size+1);
-
-	input(&step1[0], "0");
-	input(&step2[0], "1");
-
-	int j;
-	for (int i = 0; i < size; i++)
-	{
-		j = size - 1 - i;
-
-		if (i == 0)
-		{
-			add(accumulatedP1[i+1], accumulatedP2[i+1], step1[i], step2[i], A1, A2);
-			add(doubledP1[i], doubledP2[i], A1, A2, A1, A2);
-		}
-		else
-		{
-			add(accumulatedP1[i+1], accumulatedP2[i+1], step1[i], step2[i], doubledP1[i-1], doubledP2[i-1]);
-			add(doubledP1[i], doubledP2[i], doubledP1[i-1], doubledP2[i-1], doubledP1[i-1], doubledP2[i-1]);
-		}
-
-		element f1, f2, f4, f5;
-		init(&f1);
-		init(&f2);
-		init(&f4);
-		init(&f5);
-
-		mul(&f1, &accumulatedP1[i+1], &bits[i]);
-		mul(&f2, &accumulatedP2[i+1], &bits[i]);
-
-		int one_alone = 1;
-		int one_neg = -1;
-
-		mul_constants(&f4, &one_neg, &bits[i], &one_alone, &step1[i]);
-		mul_constants(&f5, &one_neg, &bits[i], &one_alone, &step2[i]);
-
-		if(i+1 != size)
-		{
-			add3mul(&step1[i+1], &f1, &f4, &step1[i], &one);
-			add3mul(&step2[i+1], &f2, &f5, &step2[i], &one);
-		}
-		else
-		{
-			add3mul(&mulOut1, &f1, &f4, &step1[i], &one);
-			add3mul(&mulOut2, &f2, &f5, &step2[i], &one);
-		}
-	}
+    element accumulatedP1[size + 1];
+    element accumulatedP2[size + 1];
+
+    element step1[size + 1];
+    element step2[size + 1];
+
+    element doubledP1[size];
+    element doubledP2[size];
+
+    element oneNeg;
+    init(&oneNeg);
+    input(&oneNeg, "-1");
+
+    init_array(doubledP1, size);
+    init_array(doubledP2, size);
+
+    init_array(accumulatedP1, size + 1);
+    init_array(accumulatedP2, size + 1);
+    init_array(step1, size + 1);
+    init_array(step2, size + 1);
+
+    input(&step1[0], "0");
+    input(&step2[0], "1");
+
+    int j;
+    for (int i = 0; i < size; i++)
+    {
+        j = size - 1 - i;
+
+        if (i == 0)
+        {
+            add(accumulatedP1[i + 1], accumulatedP2[i + 1], step1[i], step2[i], A1, A2);
+            add(doubledP1[i], doubledP2[i], A1, A2, A1, A2);
+        }
+        else
+        {
+            add(accumulatedP1[i + 1], accumulatedP2[i + 1], step1[i], step2[i], doubledP1[i - 1],
+                doubledP2[i - 1]);
+            add(doubledP1[i], doubledP2[i], doubledP1[i - 1], doubledP2[i - 1], doubledP1[i - 1],
+                doubledP2[i - 1]);
+        }
+
+        element f1, f2, f4, f5;
+        init(&f1);
+        init(&f2);
+        init(&f4);
+        init(&f5);
+
+        mul(&f1, &accumulatedP1[i + 1], &bits[i]);
+        mul(&f2, &accumulatedP2[i + 1], &bits[i]);
+
+        int one_alone = 1;
+        int one_neg = -1;
+
+        mul_constants(&f4, &one_neg, &bits[i], &one_alone, &step1[i]);
+        mul_constants(&f5, &one_neg, &bits[i], &one_alone, &step2[i]);
+
+        if (i + 1 != size)
+        {
+            add3mul(&step1[i + 1], &f1, &f4, &step1[i], &one);
+            add3mul(&step2[i + 1], &f2, &f5, &step2[i], &one);
+        }
+        else
+        {
+            add3mul(&mulOut1, &f1, &f4, &step1[i], &one);
+            add3mul(&mulOut2, &f2, &f5, &step2[i], &one);
+        }
+    }
 }
 
-void to_bits(element *bits, element val, int size)
+void to_bits(element* bits, element val, int size)
 {
-	mpz_t t1, t2, t3, total;
-	mpz_init(t1);
-	mpz_init(t2);
-	mpz_init(t3);
-	mpz_init(total);
-
-	mpz_set_str(t2, "1", 10);
-
-	element b[size];
-
-	for (int i = 0; i < size; i++)
-	{
-		if(!setParams)
-		{
-			mpz_t factor;
-			mpz_init(factor);
-			fr_to_mpz(&factor, &uw[val.index]);
-			mpz_tdiv_q_2exp(t1, factor, i);
-			mpz_and(t3, t1, t2);
-		}
-
-		char buff[2048];
-		mpz_get_str(buff, 10, t3);
-		input(&bits[i], buff);
-
-		mpz_ui_pow_ui(total, 2, i);
-
-		mclBnFr one_mpz;
-		mclBnFr_setInt(&one_mpz, 1);
-
-		init(&b[i]);
-		mclBnFr factor;
-		mpz_to_fr(&factor, &total);
-		mul_big_constants(&b[i], &factor, &bits[i], &one_mpz, &one);
-	}
-
-	element fa;
-	init(&fa);
-
-	addsmul(&fa, &size, b, &one);
-	assert_equal(&fa, &val);
+    mpz_t t1, t2, t3, total;
+    mpz_init(t1);
+    mpz_init(t2);
+    mpz_init(t3);
+    mpz_init(total);
+
+    mpz_set_str(t2, "1", 10);
+
+    element b[size];
+
+    for (int i = 0; i < size; i++)
+    {
+        if (!setParams)
+        {
+            mpz_t factor;
+            mpz_init(factor);
+            fr_to_mpz(&factor, &uw[val.index]);
+            mpz_tdiv_q_2exp(t1, factor, i);
+            mpz_and(t3, t1, t2);
+        }
+
+        char buff[2048];
+        mpz_get_str(buff, 10, t3);
+        input(&bits[i], buff);
+
+        mpz_ui_pow_ui(total, 2, i);
+
+        mclBnFr one_mpz;
+        mclBnFr_setInt(&one_mpz, 1);
+
+        init(&b[i]);
+        mclBnFr factor;
+        mpz_to_fr(&factor, &total);
+        mul_big_constants(&b[i], &factor, &bits[i], &one_mpz, &one);
+    }
+
+    element fa;
+    init(&fa);
+
+    addsmul(&fa, &size, b, &one);
+    assert_equal(&fa, &val);
 }
 
 typedef struct
 {
-    char *x; 
-    char *y;
+    char* x;
+    char* y;
 } point;
 
 typedef struct
 {
-    point R; 
-    char *S;
+    point R;
+    char* S;
 } eddsa_signature;
\ No newline at end of file
diff --git a/src/bench.c b/src/bench.c
index c6c0335..f9ce006 100644
--- a/src/bench.c
+++ b/src/bench.c
@@ -7,21 +7,21 @@ void bench_circuit()
     element a;
     init_public(&a);
 
-	element arr[mulsize+1];
-	init_array(arr, mulsize+1);
+    element arr[mulsize + 1];
+    init_array(arr, mulsize + 1);
 
-	input(&a, "1234");
-	input(&arr[0], "5678");
+    input(&a, "1234");
+    input(&arr[0], "5678");
 
-	for (int i = 1; i <= mulsize; i++)
-	{
-		mul(&arr[i], &a, &arr[i-1]);
-	}
+    for (int i = 1; i <= mulsize; i++)
+    {
+        mul(&arr[i], &a, &arr[i - 1]);
+    }
 }
 
-int main(int argc, char *argv[])
-{   
-    bench = 1; 
+int main(int argc, char* argv[])
+{
+    bench = 1;
     if (argc < 3)
     {
         printf("******************* ZPiE v0.5 *******************\n");
@@ -36,11 +36,13 @@ int main(int argc, char *argv[])
         exit(0);
     }
 
-    if ((argc == 4) && (strcmp(argv[3], "-l") == 0)) logs = 1;
+    if ((argc == 4) && (strcmp(argv[3], "-l") == 0))
+        logs = 1;
 
     printf("******************* ZPiE v0.5 *******************\n");
 
-    if ((strcmp(argv[1], "-s") == 0) || (strcmp(argv[1], "-p") == 0) || (strcmp(argv[1], "-v") == 0))
+    if ((strcmp(argv[1], "-s") == 0) || (strcmp(argv[1], "-p") == 0) ||
+        (strcmp(argv[1], "-v") == 0))
     {
         mulsize = strtol(argv[2], NULL, 10);
         init_setup(&bench_circuit);
@@ -54,20 +56,19 @@ int main(int argc, char *argv[])
     {
         printf("--- Starting ZPiE - Bulletproofs...\n");
         printf("  |--- # of bits : %s\n", argv[2]);
-        printf("  |--- # of aggregated proofs: %s\n", argv[3]);       
+        printf("  |--- # of aggregated proofs: %s\n", argv[3]);
     }
-    #ifdef MULTI_SET
+#ifdef MULTI_SET
     printf("  |--- Multi-core execution: ON\n");
-    #else
+#else
     printf("  |--- Multi-core execution: OFF\n");
-    #endif
+#endif
 
-    #ifdef BN128
+#ifdef BN128
     printf("  |--- Elliptic curve: BN128\n");
-    #else
+#else
     printf("  |--- Elliptic curve: BLS12_381\n");
-    #endif
-
+#endif
 
     if (strcmp(argv[1], "-s") == 0)
     {
diff --git a/src/bulletproofs/bulletproofs.c b/src/bulletproofs/bulletproofs.c
index e8ea816..1a564ca 100644
--- a/src/bulletproofs/bulletproofs.c
+++ b/src/bulletproofs/bulletproofs.c
@@ -1,23 +1,23 @@
 mclBnG1 Gb, Hb, Ub;
 mclBnG1 *G, *H;
-mclBnG1 *V;
+mclBnG1* V;
 mclBnG1 A, S;
 mclBnFr y, z;
 mclBnFr x, t_inner, tx, mu;
 mclBnG1 T1, T2;
-mclBnG1 *Hp;
+mclBnG1* Hp;
 mclBnFr xp;
-mclBnFr *xp_vec;
+mclBnFr* xp_vec;
 mclBnG1 *L_vec, *R_vec;
 mclBnFr *l, *r;
-mclBnFr *two_vec;
-mclBnFr *y_vec;
-mclBnFr *y_vec_inv;
-mclBnFr *gammas;
+mclBnFr* two_vec;
+mclBnFr* y_vec;
+mclBnFr* y_vec_inv;
+mclBnFr* gammas;
 
 int userGammas = 0;
 
-void bulletproof_prove(unsigned char *si[])
+void bulletproof_prove(unsigned char* si[])
 {
     struct timespec begin, end;
     double elapsed;
@@ -34,10 +34,10 @@ void bulletproof_prove(unsigned char *si[])
     mclBnFr frFactor, frFactor2, frFactor3, frFactor4;
 
     mclBnFr *aL, *aR;
-    aL = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
-    aR = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
+    aL = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
+    aR = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
 
-    for (int i = 0; i < Nb*Mc; i++)
+    for (int i = 0; i < Nb * Mc; i++)
     {
         mclBnFr_clear(&aL[i]);
     }
@@ -49,12 +49,13 @@ void bulletproof_prove(unsigned char *si[])
     for (int j = 0; j < Mc; j++)
     {
         // FIXME
-        //mclBnFr_setStr(&v[j], si[j], strlen(si[j]), 10);
+        // mclBnFr_setStr(&v[j], si[j], strlen(si[j]), 10);
         mclBnFr_getStr(buff, sizeof(buff), &v[j], 2);
 
         for (int i = 0; i < strlen(buff); i++)
         {
-            if(buff[strlen(buff) - 1 - i] == '1') mclBnFr_setInt(&aL[i + (j*Nb)], 1);
+            if (buff[strlen(buff) - 1 - i] == '1')
+                mclBnFr_setInt(&aL[i + (j * Nb)], 1);
         }
     }
 
@@ -64,8 +65,8 @@ void bulletproof_prove(unsigned char *si[])
     mclBnFr_setByCSPRNG(&alpha);
 
     mclBnFr *sL, *sR;
-    sL = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
-    sR = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
+    sL = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
+    sR = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
 
     mclBnFr rho;
     mclBnFr_setByCSPRNG(&rho);
@@ -73,7 +74,7 @@ void bulletproof_prove(unsigned char *si[])
     mclBnG1_mul(&A, &Hb, &alpha);
     mclBnG1_mul(&S, &Hb, &rho);
 
-    #pragma omp parallel for
+#pragma omp parallel for
     for (int i = 0; i < Mc; i++)
     {
         // compute commitment V
@@ -83,29 +84,30 @@ void bulletproof_prove(unsigned char *si[])
         mclBnG1_add(&V[i], &V[i], &g1Tmp);
     }
 
-    for (int i = 0; i < Nb*Mc; i++)
+    for (int i = 0; i < Nb * Mc; i++)
     {
         mclBnFr_sub(&aR[i], &aL[i], &one);
-        
+
         mclBnFr_setByCSPRNG(&sL[i]);
         mclBnFr_setByCSPRNG(&sR[i]);
     }
 
     // compute commitment A
-    for (int i = 0; i < Nb*Mc; i++)
+    for (int i = 0; i < Nb * Mc; i++)
     {
-        if (mclBnFr_isOne(&aL[i])) mclBnG1_add(&A, &A, &G[i]);
+        if (mclBnFr_isOne(&aL[i]))
+            mclBnG1_add(&A, &A, &G[i]);
     }
 
     mclBnG1 A_chunk;
-    mult_exp(&A_chunk, H, aR, Nb*Mc);
+    mult_exp(&A_chunk, H, aR, Nb * Mc);
     mclBnG1_add(&A, &A, &A_chunk);
 
     // compute commitment S
     mclBnG1 S_chunk;
-    mult_exp(&S_chunk, G, sL, Nb*Mc);
+    mult_exp(&S_chunk, G, sL, Nb * Mc);
     mclBnG1_add(&S, &S, &S_chunk);
-    mult_exp(&S_chunk, H, sR, Nb*Mc);
+    mult_exp(&S_chunk, H, sR, Nb * Mc);
     mclBnG1_add(&S, &S, &S_chunk);
 
     transcript_add_G1(&A);
@@ -121,9 +123,9 @@ void bulletproof_prove(unsigned char *si[])
     mclBnFr_setInt(&y_vec[0], 1);
     mclBnFr_mul(&y_vec[1], &y_vec[0], &y);
 
-    for (int i = 2; i < Nb*Mc; i++)
+    for (int i = 2; i < Nb * Mc; i++)
     {
-        mclBnFr_mul(&y_vec[i], &y_vec[i-1], &y);
+        mclBnFr_mul(&y_vec[i], &y_vec[i - 1], &y);
     }
 
     mclBnFr t1, t2;
@@ -131,12 +133,13 @@ void bulletproof_prove(unsigned char *si[])
     mclBnFr_clear(&t2);
     mclBnFr_clear(&frFactor3);
     mclBnFr_mul(&frFactor3, &one, &z);
-    for (int i = 0; i < Nb*Mc; i++)
+    for (int i = 0; i < Nb * Mc; i++)
     {
         mclBnFr_add(&frFactor, &aR[i], &z);
         mclBnFr_mul(&frFactor, &y_vec[i], &frFactor);
 
-        if (i % Nb == 0) mclBnFr_mul(&frFactor3, &frFactor3, &z);
+        if (i % Nb == 0)
+            mclBnFr_mul(&frFactor3, &frFactor3, &z);
         mclBnFr_mul(&frFactor2, &two_vec[i % Nb], &frFactor3);
 
         mclBnFr_add(&frFactor, &frFactor, &frFactor2);
@@ -175,7 +178,7 @@ void bulletproof_prove(unsigned char *si[])
     mclBnFr_clear(&frFactor2);
     mclBnFr_mul(&frFactor2, &one, &z);
 
-    for (int i = 0; i < Nb*Mc; i++)
+    for (int i = 0; i < Nb * Mc; i++)
     {
         mclBnFr_sub(&l[i], &aL[i], &z);
         mclBnFr_mul(&frFactor, &sL[i], &x);
@@ -186,7 +189,8 @@ void bulletproof_prove(unsigned char *si[])
         mclBnFr_add(&frFactor, &frFactor, &aR[i]);
         mclBnFr_mul(&frFactor, &frFactor, &y_vec[i]);
 
-        if (i % Nb == 0) mclBnFr_mul(&frFactor2, &frFactor2, &z);
+        if (i % Nb == 0)
+            mclBnFr_mul(&frFactor2, &frFactor2, &z);
         mclBnFr_mul(&r[i], &frFactor2, &two_vec[i % Nb]);
         mclBnFr_add(&r[i], &r[i], &frFactor);
 
@@ -205,7 +209,7 @@ void bulletproof_prove(unsigned char *si[])
     for (int i = 1; i < Mc + 1; i++)
     {
         mclBnFr_mul(&frFactor2, &frFactor2, &z);
-        mclBnFr_mul(&frFactor, &frFactor2, &gammas[i-1]);
+        mclBnFr_mul(&frFactor, &frFactor2, &gammas[i - 1]);
         mclBnFr_add(&frFactor3, &frFactor3, &frFactor);
     }
 
@@ -217,15 +221,15 @@ void bulletproof_prove(unsigned char *si[])
     // inner product
     transcript_hash(&xp);
     transcript_add_Fr(&xp);
-    
+
     mclBnG1 Ubn;
     mclBnG1_mul(&Ubn, &Ub, &xp);
 
-    mclBnG1 *Gp;
-    Gp = (mclBnG1*) malloc((Nb*Mc) * sizeof(mclBnG1));
+    mclBnG1* Gp;
+    Gp = (mclBnG1*) malloc((Nb * Mc) * sizeof(mclBnG1));
 
-    #pragma omp parallel for
-    for (int i = 0; i < Nb*Mc; i++)
+#pragma omp parallel for
+    for (int i = 0; i < Nb * Mc; i++)
     {
         Gp[i] = G[i];
 
@@ -234,7 +238,7 @@ void bulletproof_prove(unsigned char *si[])
         mclBnG1_mul(&Hp[i], &H[i], &frTmp);
     }
 
-    int np = Nb*Mc;
+    int np = Nb * Mc;
     mclBnFr cl, cr;
     for (int i = 0; i < logN; i++)
     {
@@ -245,9 +249,9 @@ void bulletproof_prove(unsigned char *si[])
 
         for (int j = 0; j < np; j++)
         {
-            mclBnFr_mul(&frFactor, &l[j], &r[j+np]);
+            mclBnFr_mul(&frFactor, &l[j], &r[j + np]);
             mclBnFr_add(&cl, &cl, &frFactor);
-            mclBnFr_mul(&frFactor, &l[j+np], &r[j]);
+            mclBnFr_mul(&frFactor, &l[j + np], &r[j]);
             mclBnFr_add(&cr, &cr, &frFactor);
         }
 
@@ -256,15 +260,15 @@ void bulletproof_prove(unsigned char *si[])
         mclBnG1_mul(&R, &Ubn, &cr);
 
         mclBnG1 L_chunk;
-        mult_exp(&L_chunk, Gp+np, l, np);
+        mult_exp(&L_chunk, Gp + np, l, np);
         mclBnG1_add(&L, &L, &L_chunk);
-        mult_exp(&L_chunk, Hp, r+np, np);
+        mult_exp(&L_chunk, Hp, r + np, np);
         mclBnG1_add(&L, &L, &L_chunk);
 
         mclBnG1 R_chunk;
-        mult_exp(&R_chunk, Gp, l+np, np);
+        mult_exp(&R_chunk, Gp, l + np, np);
         mclBnG1_add(&R, &R, &R_chunk);
-        mult_exp(&R_chunk, Hp+np, r, np);
+        mult_exp(&R_chunk, Hp + np, r, np);
         mclBnG1_add(&R, &R, &R_chunk);
 
         transcript_add_G1(&L);
@@ -275,29 +279,29 @@ void bulletproof_prove(unsigned char *si[])
 
         mclBnFr_inv(&frFactor, &xp);
 
-        #pragma omp parallel for
+#pragma omp parallel for
         for (int j = 0; j < np; j++)
         {
             mclBnG1 g1Tmp;
             mclBnFr frTmp;
             mclBnG1_mul(&g1Tmp, &Gp[j], &frFactor);
-            mclBnG1_mul(&Gp[j], &Gp[j+np], &xp);
+            mclBnG1_mul(&Gp[j], &Gp[j + np], &xp);
             mclBnG1_add(&Gp[j], &Gp[j], &g1Tmp);
 
             mclBnG1_mul(&Hp[j], &Hp[j], &xp);
-            mclBnG1_mul(&g1Tmp, &Hp[j+np], &frFactor);
+            mclBnG1_mul(&g1Tmp, &Hp[j + np], &frFactor);
             mclBnG1_add(&Hp[j], &Hp[j], &g1Tmp);
 
             mclBnFr_mul(&l[j], &l[j], &xp);
-            mclBnFr_mul(&frTmp, &l[j+np], &frFactor);
+            mclBnFr_mul(&frTmp, &l[j + np], &frFactor);
             mclBnFr_add(&l[j], &l[j], &frTmp);
 
             mclBnFr_mul(&frTmp, &r[j], &frFactor);
-            mclBnFr_mul(&r[j], &r[j+np], &xp);
+            mclBnFr_mul(&r[j], &r[j + np], &xp);
             mclBnFr_add(&r[j], &r[j], &frTmp);
         }
     }
-    
+
     bulletproof_save();
 
     clock_gettime(CLOCK_MONOTONIC, &end);
@@ -326,7 +330,7 @@ int bulletproof_verify()
     mclBnG1 g1Factor;
 
     mclBnFr z2;
-    
+
     mclBnG1 P, Pp;
     mclBnFr_mul(&z2, &z, &z);
     mclBnFr_setInt(&y_vec[0], 1);
@@ -334,9 +338,9 @@ int bulletproof_verify()
     mclBnFr_mul(&y_vec[1], &y_vec[0], &y);
     mclBnFr_inv(&y_vec_inv[1], &y_vec[1]);
 
-    for (int i = 2; i < Nb*Mc; i++)
+    for (int i = 2; i < Nb * Mc; i++)
     {
-        mclBnFr_mul(&y_vec[i], &y_vec[i-1], &y);
+        mclBnFr_mul(&y_vec[i], &y_vec[i - 1], &y);
         mclBnFr_inv(&y_vec_inv[i], &y_vec[i]);
     }
 
@@ -346,16 +350,17 @@ int bulletproof_verify()
     mclBnFr_clear(&frFactor3);
     mclBnFr_mul(&frFactor3, &one, &z);
 
-    mclBnFr *frFactor_vec;
-    frFactor_vec = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
-    mclBnFr *frFactor_vec2;
-    frFactor_vec2 = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
+    mclBnFr* frFactor_vec;
+    frFactor_vec = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
+    mclBnFr* frFactor_vec2;
+    frFactor_vec2 = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
     mclBnG1 P_chunk;
 
-    for (int i = 0; i < Nb*Mc; i++)
+    for (int i = 0; i < Nb * Mc; i++)
     {
         mclBnFr_mul(&frFactor, &z, &y_vec[i]);
-        if (i % Nb == 0) mclBnFr_mul(&frFactor3, &frFactor3, &z);
+        if (i % Nb == 0)
+            mclBnFr_mul(&frFactor3, &frFactor3, &z);
         mclBnFr_mul(&frFactor2, &frFactor3, &two_vec[i % Nb]);
         mclBnFr_add(&frFactor_vec[i], &frFactor, &frFactor2);
 
@@ -363,9 +368,9 @@ int bulletproof_verify()
         mclBnFr_neg(&frFactor_vec2[i], &z);
     }
 
-    mult_exp(&P_chunk, H, frFactor_vec, Nb*Mc); // H represents Hp due to precomputation
+    mult_exp(&P_chunk, H, frFactor_vec, Nb * Mc); // H represents Hp due to precomputation
     mclBnG1_add(&P, &P, &P_chunk);
-    mult_exp(&P_chunk, G, frFactor_vec2, Nb*Mc);
+    mult_exp(&P_chunk, G, frFactor_vec2, Nb * Mc);
     mclBnG1_add(&P, &P, &P_chunk);
 
     mclBnFr_neg(&frFactor, &mu);
@@ -382,7 +387,7 @@ int bulletproof_verify()
     mclBnFr_clear(&frFactor);
     mclBnFr_clear(&frFactor2);
 
-    for (int i = 0; i < Nb*Mc; i++)
+    for (int i = 0; i < Nb * Mc; i++)
     {
         mclBnFr_add(&frFactor, &frFactor, &y_vec[i]);
     }
@@ -404,14 +409,14 @@ int bulletproof_verify()
         mclBnFr_mul(&frFactor3, &frFactor, &frFactor2);
         mclBnFr_add(&frFactor4, &frFactor4, &frFactor3);
     }
-    
+
     mclBnFr_sub(&delta_yz, &delta_yz, &frFactor4);
 
     mclBnFr z_vec[Mc];
     mclBnFr_setInt(&z_vec[0], 1);
     for (int i = 1; i < Mc; i++)
     {
-        mclBnFr_mul(&z_vec[i], &z_vec[i-1], &z);
+        mclBnFr_mul(&z_vec[i], &z_vec[i - 1], &z);
     }
 
     mclBnG1 CL, CR;
@@ -426,27 +431,28 @@ int bulletproof_verify()
     }
 
     mult_exp(&CR, V, frFactor_vec, Mc);
-    
+
     mclBnG1_mul(&g1Factor, &Gb, &delta_yz);
     mclBnG1_add(&CR, &CR, &g1Factor);
     mclBnG1_mul(&g1Factor, &T1, &x);
     mclBnG1_add(&CR, &CR, &g1Factor);
     mclBnG1_mul(&g1Factor, &T2, &x);
     mclBnG1_mul(&g1Factor, &g1Factor, &x);
-    mclBnG1_add(&CR, &CR, &g1Factor);   
+    mclBnG1_add(&CR, &CR, &g1Factor);
 
     int cond1 = mclBnG1_isEqual(&CL, &CR);
 
-    mclBnFr *s_vec;
-    s_vec = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
+    mclBnFr* s_vec;
+    s_vec = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
 
-    for (int i = 0; i < Nb*Mc; i++)
+    for (int i = 0; i < Nb * Mc; i++)
     {
         mclBnFr_setInt(&s_vec[i], 1);
         for (int j = 0; j < logN; j++)
         {
             int bin = i >> (logN - 1 - j);
-            if (bin & 1) mclBnFr_mul(&s_vec[i], &s_vec[i], &xp_vec[j]);
+            if (bin & 1)
+                mclBnFr_mul(&s_vec[i], &s_vec[i], &xp_vec[j]);
             else
             {
                 mclBnFr_inv(&frFactor, &xp_vec[j]);
@@ -461,7 +467,7 @@ int bulletproof_verify()
     mclBnFr_mul(&frFactor, &l[0], &r[0]);
     mclBnG1_mul(&LHS, &Ub, &frFactor);
 
-    for (int i = 0; i < Nb*Mc; i++)
+    for (int i = 0; i < Nb * Mc; i++)
     {
         mclBnFr_mul(&frFactor_vec[i], &s_vec[i], &l[0]);
         mclBnFr_inv(&frFactor, &s_vec[i]);
@@ -470,9 +476,9 @@ int bulletproof_verify()
         mclBnFr_mul(&frFactor_vec2[i], &frFactor, &r[0]);
     }
 
-    mult_exp(&LHS_chunk, G, frFactor_vec, Nb*Mc);
+    mult_exp(&LHS_chunk, G, frFactor_vec, Nb * Mc);
     mclBnG1_add(&LHS, &LHS, &LHS_chunk);
-    mult_exp(&LHS_chunk, H, frFactor_vec2, Nb*Mc); // H represents Hp due to precomputation
+    mult_exp(&LHS_chunk, H, frFactor_vec2, Nb * Mc); // H represents Hp due to precomputation
     mclBnG1_add(&LHS, &LHS, &LHS_chunk);
 
     mclBnG1_clear(&RHS);
@@ -504,10 +510,11 @@ int bulletproof_verify()
         }
 
         return 1;
-    } 
+    }
     else
     {
-        if (bench) printf("\033[1;31m[FAIL] :\033[0m Bulletproof INCORRECT."); 
+        if (bench)
+            printf("\033[1;31m[FAIL] :\033[0m Bulletproof INCORRECT.");
         return 0;
     }
 }
@@ -516,7 +523,7 @@ void bulletproof_save()
 {
     char buff[2048];
 
-    FILE *fbp;
+    FILE* fbp;
     fbp = fopen("data/bulletproof.params", "w");
 
     for (int i = 0; i < Mc; i++)
@@ -546,7 +553,7 @@ void bulletproof_read()
 {
     char buff[2048];
 
-    FILE *fbp;
+    FILE* fbp;
     fbp = fopen("data/bulletproof.params", "r");
 
     for (int i = 0; i < Mc; i++)
@@ -593,9 +600,9 @@ void bulletproof_read()
         fgets(buff, sizeof buff, fbp);
         mclBnG1_setStr(&L_vec[i], buff, strlen(buff), 10);
         fgets(buff, sizeof buff, fbp);
-        mclBnG1_setStr(&R_vec[i], buff, strlen(buff), 10);  
+        mclBnG1_setStr(&R_vec[i], buff, strlen(buff), 10);
         fgets(buff, sizeof buff, fbp);
-        mclBnFr_setStr(&xp_vec[i], buff, strlen(buff), 10);      
+        mclBnFr_setStr(&xp_vec[i], buff, strlen(buff), 10);
     }
 
     fclose(fbp);
@@ -615,39 +622,40 @@ static inline void bulletproof_init(int Nb_set, int Mc_set)
     Mc = Mc_set;
 
     struct stat st = {0};
-    if (stat("data", &st) == -1) mkdir("data", 0700);
+    if (stat("data", &st) == -1)
+        mkdir("data", 0700);
 
     mclBn_init(USEDCURVE, MCLBN_COMPILED_TIME_VAR);
 
-    logN = log2(Nb*Mc);
-    transcript = (char *) malloc(1024 * logN * sizeof(char));
+    logN = log2(Nb * Mc);
+    transcript = (char*) malloc(1024 * logN * sizeof(char));
 
-    G = (mclBnG1*) malloc((Nb*Mc) * sizeof(mclBnG1));
-    H = (mclBnG1*) malloc((Nb*Mc) * sizeof(mclBnG1));
+    G = (mclBnG1*) malloc((Nb * Mc) * sizeof(mclBnG1));
+    H = (mclBnG1*) malloc((Nb * Mc) * sizeof(mclBnG1));
     V = (mclBnG1*) malloc((Mc) * sizeof(mclBnG1));
-    Hp = (mclBnG1*) malloc((Nb*Mc) * sizeof(mclBnG1));
+    Hp = (mclBnG1*) malloc((Nb * Mc) * sizeof(mclBnG1));
     xp_vec = (mclBnFr*) malloc((logN) * sizeof(mclBnFr));
     L_vec = (mclBnG1*) malloc((logN) * sizeof(mclBnG1));
     R_vec = (mclBnG1*) malloc((logN) * sizeof(mclBnG1));
-    l = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
-    r = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
-    two_vec = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
-    y_vec = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
-    y_vec_inv = (mclBnFr*) malloc((Nb*Mc) * sizeof(mclBnFr));
+    l = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
+    r = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
+    two_vec = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
+    y_vec = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
+    y_vec_inv = (mclBnFr*) malloc((Nb * Mc) * sizeof(mclBnFr));
     gammas = (mclBnFr*) malloc((Mc) * sizeof(mclBnFr));
 
     mclBnFr_setInt(&two_vec[0], 1);
     mclBnFr_setInt(&two_vec[1], 2);
 
-    for (int i = 2; i < Nb*Mc; i++)
+    for (int i = 2; i < Nb * Mc; i++)
     {
-        mclBnFr_mul(&two_vec[i], &two_vec[i-1], &two_vec[1]);
+        mclBnFr_mul(&two_vec[i], &two_vec[i - 1], &two_vec[1]);
     }
 
     mclBnG1 Gen;
     mclBnFr seed;
     mclBnG1_setStr(&Gen, GGEN, strlen(GGEN), 10);
-    
+
     mclBnFr_setStr(&seed, SEED1, strlen(SEED1), 10);
     mclBnG1_mul(&Gb, &Gen, &seed);
     mclBnFr_setStr(&seed, SEED2, strlen(SEED2), 10);
@@ -656,16 +664,16 @@ static inline void bulletproof_init(int Nb_set, int Mc_set)
     mclBnG1_mul(&Ub, &Gen, &seed);
 
     mclBnG1_clear(&G[0]);
-    mclBnG1_clear(&H[0]); 
+    mclBnG1_clear(&H[0]);
 
-    for (int i = 1; i < Nb*Mc; i++)
+    for (int i = 1; i < Nb * Mc; i++)
     {
-        mclBnG1_add(&G[i], &G[i-1], &Gb);
-        mclBnG1_add(&H[i], &H[i-1], &Hb);
+        mclBnG1_add(&G[i], &G[i - 1], &Gb);
+        mclBnG1_add(&H[i], &H[i - 1], &Hb);
     }
 }
 
-static inline void bulletproof_get_context(context *ctx)
+static inline void bulletproof_get_context(context* ctx)
 {
     ctx->V = V;
     ctx->G = Gb;
diff --git a/src/common/fourier.c b/src/common/fourier.c
index dd7b99a..a0707eb 100644
--- a/src/common/fourier.c
+++ b/src/common/fourier.c
@@ -1,9 +1,10 @@
-void fft(size_t arr, mclBnFr domain[], mclBnFr *o)
+void fft(size_t arr, mclBnFr domain[], mclBnFr* o)
 {
-    if (arr == 1) return;
+    if (arr == 1)
+        return;
     else
     {
-        size_t arrNew = arr/2;
+        size_t arrNew = arr / 2;
 
         mclBnFr oddDom[arrNew];
         mclBnFr oddVals[arrNew];
@@ -11,9 +12,9 @@ void fft(size_t arr, mclBnFr domain[], mclBnFr *o)
 
         for (int i = 0; i < arrNew; i++)
         {
-            oddDom[i] = domain[2*i];
-            oddVals[i] = o[2*i];
-            evenVals[i] = o[(2*i)+1];
+            oddDom[i] = domain[2 * i];
+            oddVals[i] = o[2 * i];
+            evenVals[i] = o[(2 * i) + 1];
         }
 
         fft(arrNew, oddDom, oddVals);
@@ -23,12 +24,12 @@ void fft(size_t arr, mclBnFr domain[], mclBnFr *o)
         {
             mclBnFr_mul(&oddDom[i], &evenVals[i], &domain[i]);
             mclBnFr_add(&o[i], &oddVals[i], &oddDom[i]);
-            mclBnFr_sub(&o[i+arrNew], &oddVals[i], &oddDom[i]);
+            mclBnFr_sub(&o[i + arrNew], &oddVals[i], &oddDom[i]);
         }
     }
 }
 
-void ifft(size_t arr, mclBnFr domain[], mclBnFr *o)
+void ifft(size_t arr, mclBnFr domain[], mclBnFr* o)
 {
     fft(arr, domain, o);
 
@@ -48,11 +49,11 @@ void ifft(size_t arr, mclBnFr domain[], mclBnFr *o)
 
     for (int i = 1; i < arr; i++)
     {
-        mclBnFr_mul(&o[i], &out[arr-i], &frFactor);
+        mclBnFr_mul(&o[i], &out[arr - i], &frFactor);
     }
 }
 
-void ifft_t(size_t arr, mclBnFr domain[], mclBnFr *o)
+void ifft_t(size_t arr, mclBnFr domain[], mclBnFr* o)
 {
     fft(arr, domain, o);
 
@@ -67,7 +68,7 @@ void ifft_t(size_t arr, mclBnFr domain[], mclBnFr *o)
 
     for (int i = 1; i < arr; i++)
     {
-        mclBnFr_mul(&o[i], &out[arr-i], &rsigma[i]);
+        mclBnFr_mul(&o[i], &out[arr - i], &rsigma[i]);
     }
 
     fft(arr, domain, o);
diff --git a/src/common/sha256.c b/src/common/sha256.c
index 41ba180..1488988 100644
--- a/src/common/sha256.c
+++ b/src/common/sha256.c
@@ -13,146 +13,151 @@
 *********************************************************************/
 
 /*************************** HEADER FILES ***************************/
-#include <stdlib.h>
-#include <memory.h>
 #include "sha256.h"
+#include <memory.h>
+#include <stdlib.h>
 
 /****************************** MACROS ******************************/
-#define ROTLEFT(a,b) (((a) << (b)) | ((a) >> (32-(b))))
-#define ROTRIGHT(a,b) (((a) >> (b)) | ((a) << (32-(b))))
+#define ROTLEFT(a, b) (((a) << (b)) | ((a) >> (32 - (b))))
+#define ROTRIGHT(a, b) (((a) >> (b)) | ((a) << (32 - (b))))
 
-#define CH(x,y,z) (((x) & (y)) ^ (~(x) & (z)))
-#define MAJ(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
-#define EP0(x) (ROTRIGHT(x,2) ^ ROTRIGHT(x,13) ^ ROTRIGHT(x,22))
-#define EP1(x) (ROTRIGHT(x,6) ^ ROTRIGHT(x,11) ^ ROTRIGHT(x,25))
-#define SIG0(x) (ROTRIGHT(x,7) ^ ROTRIGHT(x,18) ^ ((x) >> 3))
-#define SIG1(x) (ROTRIGHT(x,17) ^ ROTRIGHT(x,19) ^ ((x) >> 10))
+#define CH(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
+#define MAJ(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
+#define EP0(x) (ROTRIGHT(x, 2) ^ ROTRIGHT(x, 13) ^ ROTRIGHT(x, 22))
+#define EP1(x) (ROTRIGHT(x, 6) ^ ROTRIGHT(x, 11) ^ ROTRIGHT(x, 25))
+#define SIG0(x) (ROTRIGHT(x, 7) ^ ROTRIGHT(x, 18) ^ ((x) >> 3))
+#define SIG1(x) (ROTRIGHT(x, 17) ^ ROTRIGHT(x, 19) ^ ((x) >> 10))
 
 /**************************** VARIABLES *****************************/
 static const WORD k[64] = {
-	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
-	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
-	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
-	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
-	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
-	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
-	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
-	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
-};
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
 
 /*********************** FUNCTION DEFINITIONS ***********************/
-void sha256_transform(SHA256_CTX *ctx, const BYTE data[])
+void sha256_transform(SHA256_CTX* ctx, const BYTE data[])
 {
-	WORD a, b, c, d, e, f, g, h, i, j, t1, t2, m[64];
-
-	for (i = 0, j = 0; i < 16; ++i, j += 4)
-		m[i] = (data[j] << 24) | (data[j + 1] << 16) | (data[j + 2] << 8) | (data[j + 3]);
-	for ( ; i < 64; ++i)
-		m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
-
-	a = ctx->state[0];
-	b = ctx->state[1];
-	c = ctx->state[2];
-	d = ctx->state[3];
-	e = ctx->state[4];
-	f = ctx->state[5];
-	g = ctx->state[6];
-	h = ctx->state[7];
-
-	for (i = 0; i < 64; ++i) {
-		t1 = h + EP1(e) + CH(e,f,g) + k[i] + m[i];
-		t2 = EP0(a) + MAJ(a,b,c);
-		h = g;
-		g = f;
-		f = e;
-		e = d + t1;
-		d = c;
-		c = b;
-		b = a;
-		a = t1 + t2;
-	}
-
-	ctx->state[0] += a;
-	ctx->state[1] += b;
-	ctx->state[2] += c;
-	ctx->state[3] += d;
-	ctx->state[4] += e;
-	ctx->state[5] += f;
-	ctx->state[6] += g;
-	ctx->state[7] += h;
+    WORD a, b, c, d, e, f, g, h, i, j, t1, t2, m[64];
+
+    for (i = 0, j = 0; i < 16; ++i, j += 4)
+        m[i] = (data[j] << 24) | (data[j + 1] << 16) | (data[j + 2] << 8) | (data[j + 3]);
+    for (; i < 64; ++i)
+        m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
+
+    a = ctx->state[0];
+    b = ctx->state[1];
+    c = ctx->state[2];
+    d = ctx->state[3];
+    e = ctx->state[4];
+    f = ctx->state[5];
+    g = ctx->state[6];
+    h = ctx->state[7];
+
+    for (i = 0; i < 64; ++i)
+    {
+        t1 = h + EP1(e) + CH(e, f, g) + k[i] + m[i];
+        t2 = EP0(a) + MAJ(a, b, c);
+        h = g;
+        g = f;
+        f = e;
+        e = d + t1;
+        d = c;
+        c = b;
+        b = a;
+        a = t1 + t2;
+    }
+
+    ctx->state[0] += a;
+    ctx->state[1] += b;
+    ctx->state[2] += c;
+    ctx->state[3] += d;
+    ctx->state[4] += e;
+    ctx->state[5] += f;
+    ctx->state[6] += g;
+    ctx->state[7] += h;
 }
 
-void sha256_init(SHA256_CTX *ctx)
+void sha256_init(SHA256_CTX* ctx)
 {
-	ctx->datalen = 0;
-	ctx->bitlen = 0;
-	ctx->state[0] = 0x6a09e667;
-	ctx->state[1] = 0xbb67ae85;
-	ctx->state[2] = 0x3c6ef372;
-	ctx->state[3] = 0xa54ff53a;
-	ctx->state[4] = 0x510e527f;
-	ctx->state[5] = 0x9b05688c;
-	ctx->state[6] = 0x1f83d9ab;
-	ctx->state[7] = 0x5be0cd19;
+    ctx->datalen = 0;
+    ctx->bitlen = 0;
+    ctx->state[0] = 0x6a09e667;
+    ctx->state[1] = 0xbb67ae85;
+    ctx->state[2] = 0x3c6ef372;
+    ctx->state[3] = 0xa54ff53a;
+    ctx->state[4] = 0x510e527f;
+    ctx->state[5] = 0x9b05688c;
+    ctx->state[6] = 0x1f83d9ab;
+    ctx->state[7] = 0x5be0cd19;
 }
 
-void sha256_update(SHA256_CTX *ctx, const BYTE data[], size_t len)
+void sha256_update(SHA256_CTX* ctx, const BYTE data[], size_t len)
 {
-	WORD i;
-
-	for (i = 0; i < len; ++i) {
-		ctx->data[ctx->datalen] = data[i];
-		ctx->datalen++;
-		if (ctx->datalen == 64) {
-			sha256_transform(ctx, ctx->data);
-			ctx->bitlen += 512;
-			ctx->datalen = 0;
-		}
-	}
+    WORD i;
+
+    for (i = 0; i < len; ++i)
+    {
+        ctx->data[ctx->datalen] = data[i];
+        ctx->datalen++;
+        if (ctx->datalen == 64)
+        {
+            sha256_transform(ctx, ctx->data);
+            ctx->bitlen += 512;
+            ctx->datalen = 0;
+        }
+    }
 }
 
-void sha256_final(SHA256_CTX *ctx, BYTE hash[])
+void sha256_final(SHA256_CTX* ctx, BYTE hash[])
 {
-	WORD i;
-
-	i = ctx->datalen;
-
-	// Pad whatever data is left in the buffer.
-	if (ctx->datalen < 56) {
-		ctx->data[i++] = 0x80;
-		while (i < 56)
-			ctx->data[i++] = 0x00;
-	}
-	else {
-		ctx->data[i++] = 0x80;
-		while (i < 64)
-			ctx->data[i++] = 0x00;
-		sha256_transform(ctx, ctx->data);
-		memset(ctx->data, 0, 56);
-	}
-
-	// Append to the padding the total message's length in bits and transform.
-	ctx->bitlen += ctx->datalen * 8;
-	ctx->data[63] = ctx->bitlen;
-	ctx->data[62] = ctx->bitlen >> 8;
-	ctx->data[61] = ctx->bitlen >> 16;
-	ctx->data[60] = ctx->bitlen >> 24;
-	ctx->data[59] = ctx->bitlen >> 32;
-	ctx->data[58] = ctx->bitlen >> 40;
-	ctx->data[57] = ctx->bitlen >> 48;
-	ctx->data[56] = ctx->bitlen >> 56;
-	sha256_transform(ctx, ctx->data);
-
-	// Since this implementation uses little endian byte ordering and SHA uses big endian,
-	// reverse all the bytes when copying the final state to the output hash.
-	for (i = 0; i < 4; ++i) {
-		hash[i]      = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 4]  = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 8]  = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0x000000ff;
-	}
+    WORD i;
+
+    i = ctx->datalen;
+
+    // Pad whatever data is left in the buffer.
+    if (ctx->datalen < 56)
+    {
+        ctx->data[i++] = 0x80;
+        while (i < 56)
+            ctx->data[i++] = 0x00;
+    }
+    else
+    {
+        ctx->data[i++] = 0x80;
+        while (i < 64)
+            ctx->data[i++] = 0x00;
+        sha256_transform(ctx, ctx->data);
+        memset(ctx->data, 0, 56);
+    }
+
+    // Append to the padding the total message's length in bits and transform.
+    ctx->bitlen += ctx->datalen * 8;
+    ctx->data[63] = ctx->bitlen;
+    ctx->data[62] = ctx->bitlen >> 8;
+    ctx->data[61] = ctx->bitlen >> 16;
+    ctx->data[60] = ctx->bitlen >> 24;
+    ctx->data[59] = ctx->bitlen >> 32;
+    ctx->data[58] = ctx->bitlen >> 40;
+    ctx->data[57] = ctx->bitlen >> 48;
+    ctx->data[56] = ctx->bitlen >> 56;
+    sha256_transform(ctx, ctx->data);
+
+    // Since this implementation uses little endian byte ordering and SHA uses big endian,
+    // reverse all the bytes when copying the final state to the output hash.
+    for (i = 0; i < 4; ++i)
+    {
+        hash[i] = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 4] = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 8] = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0x000000ff;
+    }
 }
\ No newline at end of file
diff --git a/src/common/sha256.h b/src/common/sha256.h
index 55e272e..e17ee5c 100644
--- a/src/common/sha256.h
+++ b/src/common/sha256.h
@@ -1,10 +1,10 @@
 /*********************************************************************
-* Filename:   sha256.h
-* Author:     Brad Conte (brad AT bradconte.com)
-* Copyright:
-* Disclaimer: This code is presented "as is" without any guarantees.
-* Details:    Defines the API for the corresponding SHA1 implementation.
-*********************************************************************/
+ * Filename:   sha256.h
+ * Author:     Brad Conte (brad AT bradconte.com)
+ * Copyright:
+ * Disclaimer: This code is presented "as is" without any guarantees.
+ * Details:    Defines the API for the corresponding SHA1 implementation.
+ *********************************************************************/
 
 #ifndef SHA256_H
 #define SHA256_H
@@ -13,22 +13,23 @@
 #include <stddef.h>
 
 /****************************** MACROS ******************************/
-#define SHA256_BLOCK_SIZE 32            // SHA256 outputs a 32 byte digest
+#define SHA256_BLOCK_SIZE 32 // SHA256 outputs a 32 byte digest
 
 /**************************** DATA TYPES ****************************/
-typedef unsigned char BYTE;             // 8-bit byte
-typedef unsigned int  WORD;             // 32-bit word, change to "long" for 16-bit machines
+typedef unsigned char BYTE; // 8-bit byte
+typedef unsigned int WORD;  // 32-bit word, change to "long" for 16-bit machines
 
-typedef struct {
-	BYTE data[64];
-	WORD datalen;
-	unsigned long long bitlen;
-	WORD state[8];
+typedef struct
+{
+    BYTE data[64];
+    WORD datalen;
+    unsigned long long bitlen;
+    WORD state[8];
 } SHA256_CTX;
 
 /*********************** FUNCTION DECLARATIONS **********************/
-void sha256_init(SHA256_CTX *ctx);
-void sha256_update(SHA256_CTX *ctx, const BYTE data[], size_t len);
-void sha256_final(SHA256_CTX *ctx, BYTE hash[]);
+void sha256_init(SHA256_CTX* ctx);
+void sha256_update(SHA256_CTX* ctx, const BYTE data[], size_t len);
+void sha256_final(SHA256_CTX* ctx, BYTE hash[]);
 
-#endif   // SHA256_H
\ No newline at end of file
+#endif // SHA256_H
\ No newline at end of file
diff --git a/src/common/utils.c b/src/common/utils.c
index 956b7c8..8732847 100644
--- a/src/common/utils.c
+++ b/src/common/utils.c
@@ -1,19 +1,23 @@
 double elapsedSort;
 double elapsedBosCoster;
-char *transcript;
+char* transcript;
 
-void generate_random_scalar(mclBnFr *value)
+void generate_random_scalar(mclBnFr* value)
 {
-    if (test_no_rand) mclBnFr_setInt(value, 123456);
-    else mclBnFr_setByCSPRNG(value);
+    if (test_no_rand)
+        mclBnFr_setInt(value, 123456);
+    else
+        mclBnFr_setByCSPRNG(value);
 }
 
 void log_state(int type)
 {
     if (logs)
     {
-        if (type == 0) printf(" \033[1;31m[ERROR]\033[0m\n");
-        if (type == 1) printf(" \033[1;32m[OK]\033[0m\n");
+        if (type == 0)
+            printf(" \033[1;31m[ERROR]\033[0m\n");
+        if (type == 1)
+            printf(" \033[1;32m[OK]\033[0m\n");
     }
 }
 
@@ -22,16 +26,18 @@ void log_message(char msg[])
     if (logs)
     {
         printf("\033[1;34m[log] :\033[0m %s", msg);
-    }   
+    }
 }
 
 void log_success(char msg[], int type)
 {
-    if (type == 1 && bench) printf("\033[1;32m[SUCCESS] :\033[0m %s", msg);
-    if (type == 0 && bench) printf("\033[1;31m[FAIL] :\033[0m %s", msg);
+    if (type == 1 && bench)
+        printf("\033[1;32m[SUCCESS] :\033[0m %s", msg);
+    if (type == 0 && bench)
+        printf("\033[1;31m[FAIL] :\033[0m %s", msg);
 }
 
-void init_setup(void *circuit)
+void init_setup(void* circuit)
 {
     M = 0;
     N = 0;
@@ -50,11 +56,11 @@ void init_setup(void *circuit)
 
     for (int i = 0; i < M; i++)
     {
-       mclBnFr_clear(&uw[i]);
+        mclBnFr_clear(&uw[i]);
     }
 }
 
-void init_prover(void *circuit, proving_key *pk)
+void init_prover(void* circuit, proving_key* pk)
 {
     init_setup(circuit);
 
@@ -70,10 +76,11 @@ void init_prover(void *circuit, proving_key *pk)
 
     mpz_init(pPrime);
     mpz_set_str(pPrime, PRIMESTR, 10);
-    if (bench) printf("  |--- FFT domain size : %d\n", n);
+    if (bench)
+        printf("  |--- FFT domain size : %d\n", n);
 
-    rsigma = (mclBnFr*) malloc((n) * sizeof(mclBnFr)); 
-    rsigmaInv = (mclBnFr*) malloc((n) * sizeof(mclBnFr)); 
+    rsigma = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
+    rsigmaInv = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
 
     static mpz_t shift;
     mpz_init(shift);
@@ -105,7 +112,8 @@ void init_prover(void *circuit, proving_key *pk)
 
     for (int i = 1; i < n; i++)
     {
-        if (i < n - 1) mclBnFr_mul(&rsigma[i + 1], &rsigma[i], &rand);
+        if (i < n - 1)
+            mclBnFr_mul(&rsigma[i + 1], &rsigma[i], &rand);
 
         mclBnFr_inv(&rsigmaInv[i], &rsigma[i]);
         mclBnG1_mul(&pk->xt1_rand[i], &pk->xt1[i], &rsigmaInv[i]);
@@ -118,14 +126,15 @@ void init_prover(void *circuit, proving_key *pk)
     elapsed += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
 
     log_success("ZPiE started successfully in ", 1);
-    if (bench) printf("%fs\n\n", elapsed);
+    if (bench)
+        printf("%fs\n\n", elapsed);
 }
 
-void bos_coster_bp(mclBnG1 *chunk, mclBnG1 *points, mclBnFr *scalars, int heapsize)
+void bos_coster_bp(mclBnG1* chunk, mclBnG1* points, mclBnFr* scalars, int heapsize)
 {
-    mpz_t *exp[heapsize];
+    mpz_t* exp[heapsize];
     mpz_t scalars_p[heapsize];
-    mclBnG1 *points_p;
+    mclBnG1* points_p;
     points_p = (mclBnG1*) malloc((heapsize) * sizeof(mclBnG1));
 
     for (int i = 0; i < heapsize; i++)
@@ -138,28 +147,30 @@ void bos_coster_bp(mclBnG1 *chunk, mclBnG1 *points, mclBnFr *scalars, int heapsi
     sort_list(exp, heapsize);
     while (mpz_cmp_ui(*exp[2], 0) != 0)
     {
-        mpz_sub(*exp[0], *exp[0], *exp[2]); 
-        mclBnG1_add(&points_p[exp[2]-scalars_p], &points_p[exp[0]-scalars_p], &points_p[exp[2]-scalars_p]);
+        mpz_sub(*exp[0], *exp[0], *exp[2]);
+        mclBnG1_add(&points_p[exp[2] - scalars_p], &points_p[exp[0] - scalars_p],
+                    &points_p[exp[2] - scalars_p]);
         binarymaxheap(exp, 0, heapsize);
     }
 
     mclBnFr frFactor;
     mpz_to_fr(&frFactor, exp[0]);
-    mclBnG1_mul(chunk, &points_p[exp[0]-scalars_p], &frFactor); 
+    mclBnG1_mul(chunk, &points_p[exp[0] - scalars_p], &frFactor);
 }
 
-static inline void mult_exp(mclBnG1 *chunk, mclBnG1 *points, mclBnFr *scalars, int heapsize)
+static inline void mult_exp(mclBnG1* chunk, mclBnG1* points, mclBnFr* scalars, int heapsize)
 {
     mclBnG1_mulVec(chunk, points, scalars, heapsize);
 }
 
-char *to_hex(const unsigned char *array, size_t length)
+char* to_hex(const unsigned char* array, size_t length)
 {
-    char *outstr = malloc(2 * length + 1);
-    if (!outstr) return outstr;
+    char* outstr = malloc(2 * length + 1);
+    if (!outstr)
+        return outstr;
 
-    char *p = outstr;
-    for (size_t i = 0; i < length; i++) 
+    char* p = outstr;
+    for (size_t i = 0; i < length; i++)
     {
         p += sprintf(p, "%02hhx", array[i]);
     }
@@ -167,22 +178,22 @@ char *to_hex(const unsigned char *array, size_t length)
     return outstr;
 }
 
-void transcript_hash(mclBnFr *hash)
+void transcript_hash(mclBnFr* hash)
 {
     BYTE buff_hash_bytes[SHA256_BLOCK_SIZE];
 
     SHA256_CTX ctx;
 
     sha256_init(&ctx);
-    //FIXME
-    //sha256_update(&ctx, transcript, strlen(transcript));
+    // FIXME
+    // sha256_update(&ctx, transcript, strlen(transcript));
     sha256_final(&ctx, buff_hash_bytes);
 
-    char *buff_hash = to_hex(buff_hash_bytes, sizeof buff_hash_bytes);
-    mclBnFr_setStr(hash, buff_hash, strlen(buff_hash)-1, 16);
+    char* buff_hash = to_hex(buff_hash_bytes, sizeof buff_hash_bytes);
+    mclBnFr_setStr(hash, buff_hash, strlen(buff_hash) - 1, 16);
 }
 
-static inline void transcript_add_Fr(mclBnFr *val)
+static inline void transcript_add_Fr(mclBnFr* val)
 {
     char buff[2048];
     mclBnFr_getStr(buff, sizeof(buff), val, 10);
@@ -191,7 +202,7 @@ static inline void transcript_add_Fr(mclBnFr *val)
     strcat(transcript, "\n");
 }
 
-static inline void transcript_add_G1(mclBnG1 *val)
+static inline void transcript_add_G1(mclBnG1* val)
 {
     char buff[2048];
     mclBnG1_getStr(buff, sizeof(buff), val, 10);
@@ -200,50 +211,54 @@ static inline void transcript_add_G1(mclBnG1 *val)
     strcat(transcript, "\n");
 }
 
-void binarymaxheap(mpz_t *exp[], int i, int heapsize)
+void binarymaxheap(mpz_t* exp[], int i, int heapsize)
 {
     int largest, left, right;
-    mpz_t *temp;
+    mpz_t* temp;
 
-    left = (2*i+1);
-    right = ((2*i)+2);
+    left = (2 * i + 1);
+    right = ((2 * i) + 2);
 
-    if (left >= heapsize) return;
+    if (left >= heapsize)
+        return;
     else
     {
-        if (left < (heapsize) && (mpz_cmp(*exp[left], *exp[i]) > 0)) largest = left;
-        else largest = i;
-        if (right < (heapsize) && (mpz_cmp(*exp[right], *exp[largest]) > 0)) largest = right;
+        if (left < (heapsize) && (mpz_cmp(*exp[left], *exp[i]) > 0))
+            largest = left;
+        else
+            largest = i;
+        if (right < (heapsize) && (mpz_cmp(*exp[right], *exp[largest]) > 0))
+            largest = right;
         if (largest != i)
         {
             temp = exp[i];
             exp[i] = exp[largest];
-            exp[largest] = temp; 
+            exp[largest] = temp;
 
             binarymaxheap(exp, largest, heapsize);
         }
     }
 }
 
-void sort_list(mpz_t *exp[], int heapsize)
+void sort_list(mpz_t* exp[], int heapsize)
 {
     struct timespec begin, end;
     clock_gettime(CLOCK_MONOTONIC, &begin);
 
-    for (int j = heapsize/2; j >= 0; j--)
+    for (int j = heapsize / 2; j >= 0; j--)
     {
         binarymaxheap(exp, j, heapsize);
-    }   
+    }
 
     clock_gettime(CLOCK_MONOTONIC, &end);
     elapsedSort += (end.tv_sec - begin.tv_sec);
     elapsedSort += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
 }
 
-int fr_cmp(mclBnFr *frFactor1, mclBnFr *frFactor2)
+int fr_cmp(mclBnFr* frFactor1, mclBnFr* frFactor2)
 {
     mpz_t f1, f2;
-    
+
     char buff[2048];
     mclBnFr_getStr(buff, sizeof(buff), frFactor1, 10);
     mpz_init_set_str(f1, buff, 10);
@@ -255,23 +270,26 @@ int fr_cmp(mclBnFr *frFactor1, mclBnFr *frFactor2)
 
 void log_polynomial(mpz_t P[], int size, char letter[], int idx)
 {
-	if (logs)
+    if (logs)
     {
-    	if (idx == -1) printf("%s(x) = ", letter);
-    	else printf("%s%d(x) = ", letter, idx);
+        if (idx == -1)
+            printf("%s(x) = ", letter);
+        else
+            printf("%s%d(x) = ", letter, idx);
 
-        for (int j = size-1; j >= 0; j--)
+        for (int j = size - 1; j >= 0; j--)
         {
             gmp_printf("%Zd", P[j]);
             if (j == 1)
             {
                 printf("x");
             }
-            else if (j>1)
+            else if (j > 1)
             {
                 printf("x^%d", j);
             }
-            if (j > 0) printf(" + ");
+            if (j > 0)
+                printf(" + ");
         }
         printf("\n");
     }
@@ -279,21 +297,21 @@ void log_polynomial(mpz_t P[], int size, char letter[], int idx)
 
 int get_thread()
 {
-    #ifdef MULTI_SET
-        return omp_get_thread_num();
-    #else
-        return 99;
-    #endif
+#ifdef MULTI_SET
+    return omp_get_thread_num();
+#else
+    return 99;
+#endif
 }
 
-void mpz_to_fr(mclBnFr *frFactor, mpz_t *convert)
+void mpz_to_fr(mclBnFr* frFactor, mpz_t* convert)
 {
     char buff[2048];
     mpz_get_str(buff, 10, *convert);
     mclBnFr_setStr(frFactor, buff, strlen(buff), 10);
 }
 
-void fr_to_mpz(mpz_t *convert, mclBnFr *frFactor)
+void fr_to_mpz(mpz_t* convert, mclBnFr* frFactor)
 {
     char buff[2048];
     mclBnFr_getStr(buff, sizeof(buff), frFactor, 10);
diff --git a/src/gro16/gro16.h b/src/gro16/gro16.h
index e0ecd94..8153b49 100644
--- a/src/gro16/gro16.h
+++ b/src/gro16/gro16.h
@@ -13,43 +13,43 @@ element one, oneNeg, c_mimc[91];
 int logs;
 int test_no_rand;
 
-void element_log(char *text, element *oo);
-void init(element *toAdd);
+void element_log(char* text, element* oo);
+void init(element* toAdd);
 void circuit();
-void init_array(element *toAdd, int size);
-void init_public(element *toAdd);
-void setPublic(element *set);
-void input(element *var, char *val);
-void mul(element *oo, element *lo, element *ro);
-void assert_equal(element *lo, element *ro);
-void addmul(element *oo, element *lo1, element *lo2, element *ro);
-void submul(element *oo, element *lo1, element *lo2, element *ro);
-void add3mul(element *oo, element *lo1, element *lo2, element *lo3, element *ro);
-void addmuladd(element *oo, element *lo1, element *lo2, element *ro1, element *ro2);
-void mpz_to_fr(mclBnFr *frFactor, mpz_t *convert);
-void fr_to_mpz(mpz_t *convert, mclBnFr *frFactor);
-int fr_cmp(mclBnFr *frFactor1, mclBnFr *frFactor2);
-void sort_list(mpz_t *exp[], int heapsize);
-void binarymaxheap(mpz_t *exp[], int i, int heapsize);
+void init_array(element* toAdd, int size);
+void init_public(element* toAdd);
+void setPublic(element* set);
+void input(element* var, char* val);
+void mul(element* oo, element* lo, element* ro);
+void assert_equal(element* lo, element* ro);
+void addmul(element* oo, element* lo1, element* lo2, element* ro);
+void submul(element* oo, element* lo1, element* lo2, element* ro);
+void add3mul(element* oo, element* lo1, element* lo2, element* lo3, element* ro);
+void addmuladd(element* oo, element* lo1, element* lo2, element* ro1, element* ro2);
+void mpz_to_fr(mclBnFr* frFactor, mpz_t* convert);
+void fr_to_mpz(mpz_t* convert, mclBnFr* frFactor);
+int fr_cmp(mclBnFr* frFactor1, mclBnFr* frFactor2);
+void sort_list(mpz_t* exp[], int heapsize);
+void binarymaxheap(mpz_t* exp[], int i, int heapsize);
 
 static mpz_t pPrime;
 static gmp_randstate_t state;
 
-int **L;
-int **R;
-int **O;
+int** L;
+int** R;
+int** O;
 
-mpz_t *LRO_constants;
+mpz_t* LRO_constants;
 
-static mclBnFr *AsFr;
-static mclBnFr *BsFr;
-static mclBnFr *CsFr;
+static mclBnFr* AsFr;
+static mclBnFr* BsFr;
+static mclBnFr* CsFr;
 
-static mclBnFr *rsigma;
-static mclBnFr *rsigmaInv;
+static mclBnFr* rsigma;
+static mclBnFr* rsigmaInv;
 static mclBnFr shift_fft;
 
-static mpz_t *wM;
+static mpz_t* wM;
 
 #include "../common/fourier.c"
 
@@ -77,11 +77,11 @@ struct Sigma1
     mclBnG1 alpha;
     mclBnG1 beta;
     mclBnG1 delta;
-    mclBnG1 *A;
-    mclBnG1 *B;
-    mclBnG1 *vk;
-    mclBnG1 *pk;
-    mclBnG1 *xt;
+    mclBnG1* A;
+    mclBnG1* B;
+    mclBnG1* vk;
+    mclBnG1* pk;
+    mclBnG1* xt;
 };
 
 struct Sigma2
@@ -89,17 +89,17 @@ struct Sigma2
     mclBnG2 beta;
     mclBnG2 gamma;
     mclBnG2 delta;
-    mclBnG2 *B;
+    mclBnG2* B;
 };
 
 typedef struct
 {
     mpz_t Ne;
-    mclBnFr *wM;
+    mclBnFr* wM;
 
     int qap_size;
-    int *LRO;
-    mclBnFr *LRO_constants;
+    int* LRO;
+    mclBnFr* LRO_constants;
 
     mclBnG1 alpha1;
     mclBnG1 beta1;
@@ -107,12 +107,12 @@ typedef struct
     mclBnG1 delta1;
     mclBnG2 delta2;
 
-    mclBnG1 *A1;
-    mclBnG1 *B1;
-    mclBnG2 *B2;
-    mclBnG1 *pk1;
-    mclBnG1 *xt1;
-    mclBnG1 *xt1_rand;
+    mclBnG1* A1;
+    mclBnG1* B1;
+    mclBnG2* B2;
+    mclBnG1* pk1;
+    mclBnG1* xt1;
+    mclBnG1* xt1_rand;
 } proving_key;
 
 struct mulExpResult
@@ -126,11 +126,11 @@ struct mulExpResult
 
 typedef struct
 {
-    mclBnFr *constants;
+    mclBnFr* constants;
     mclBnGT alphabetaT;
     mclBnG2 gamma2;
     mclBnG2 delta2;
-    mclBnG1 *vk1;
+    mclBnG1* vk1;
 } verifying_key;
 
 typedef struct
@@ -140,9 +140,9 @@ typedef struct
 } setup_keys;
 
 #include "../common/utils.c"
+#include "prover.c"
 #include "qap.c"
 #include "setup.c"
-#include "prover.c"
 #include "verifier.c"
 
 #endif
\ No newline at end of file
diff --git a/src/gro16/parser.c b/src/gro16/parser.c
index ec1121f..cee7dba 100644
--- a/src/gro16/parser.c
+++ b/src/gro16/parser.c
@@ -1,319 +1,336 @@
 
-void element_log(char *text, element *oo)
+void element_log(char* text, element* oo)
 {
-	//if(!setParams) gmp_printf("%s%Zd\n", text, uw[oo->index]);
+    // if(!setParams) gmp_printf("%s%Zd\n", text, uw[oo->index]);
 }
 
-void addmul(element *oo, element *lo1, element *lo2, element *ro)
+void addmul(element* oo, element* lo1, element* lo2, element* ro)
 {
-	if (setParams) N++;
-	else if (prover)
-	{
-		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
-		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
-	}
-	else
-	{
-		L[cn][lo1->index] = 1;
-		L[cn][lo2->index] = 1;
-		R[cn][ro->index] = 1;
-		O[cn][oo->index] = 1;
-
-		cn++;
-	}	
+    if (setParams)
+        N++;
+    else if (prover)
+    {
+        mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+        mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
+    }
+    else
+    {
+        L[cn][lo1->index] = 1;
+        L[cn][lo2->index] = 1;
+        R[cn][ro->index] = 1;
+        O[cn][oo->index] = 1;
+
+        cn++;
+    }
 }
 
-void addmul0(element *oo, element *lo1, element *lo2, element *ro)
+void addmul0(element* oo, element* lo1, element* lo2, element* ro)
 {
-	if (setParams) N++;
-	else if (prover)
-	{
-		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
-		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
-	}
-	else
-	{
-		L[cn][lo1->index] = 1;
-		L[cn][lo2->index] = 1;
-		R[cn][ro->index] = 1;
-
-		cn++;
-	}	
+    if (setParams)
+        N++;
+    else if (prover)
+    {
+        mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+        mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
+    }
+    else
+    {
+        L[cn][lo1->index] = 1;
+        L[cn][lo2->index] = 1;
+        R[cn][ro->index] = 1;
+
+        cn++;
+    }
 }
 
-void add3mul(element *oo, element *lo1, element *lo2, element *lo3, element *ro)
+void add3mul(element* oo, element* lo1, element* lo2, element* lo3, element* ro)
 {
-	if (setParams) N++;
-	else if (prover)
-	{
-		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
-		mclBnFr_add(&uw[oo->index], &uw[oo->index], &uw[lo3->index]);
-		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
-	}
-	else
-	{
-		L[cn][lo1->index] = 1;
-		L[cn][lo2->index] = 1;
-		L[cn][lo3->index] = 1;
-		R[cn][ro->index] = 1;
-		O[cn][oo->index] = 1;
-
-		cn++;
-	}	
+    if (setParams)
+        N++;
+    else if (prover)
+    {
+        mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+        mclBnFr_add(&uw[oo->index], &uw[oo->index], &uw[lo3->index]);
+        mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
+    }
+    else
+    {
+        L[cn][lo1->index] = 1;
+        L[cn][lo2->index] = 1;
+        L[cn][lo3->index] = 1;
+        R[cn][ro->index] = 1;
+        O[cn][oo->index] = 1;
+
+        cn++;
+    }
 }
 
-void addsmul(element *oo, int *size, element *los, element *ro)
+void addsmul(element* oo, int* size, element* los, element* ro)
 {
-	if (setParams) N++;
-	else if (prover)
-	{
-		for (int i = 0; i < *size; i++)
-		{
-			mclBnFr_add(&uw[oo->index], &uw[oo->index], &uw[los[i].index]);
-		}
-
-		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
-	}
-	else
-	{
-		for (int i = 0; i < *size; i++)
-		{
-			L[cn][los[i].index] = 1;
-		}
-
-		R[cn][ro->index] = 1;
-		O[cn][oo->index] = 1;
-
-		cn++;
-	}	
+    if (setParams)
+        N++;
+    else if (prover)
+    {
+        for (int i = 0; i < *size; i++)
+        {
+            mclBnFr_add(&uw[oo->index], &uw[oo->index], &uw[los[i].index]);
+        }
+
+        mclBnFr_mul(&uw[oo->index], &uw[oo->index], &uw[ro->index]);
+    }
+    else
+    {
+        for (int i = 0; i < *size; i++)
+        {
+            L[cn][los[i].index] = 1;
+        }
+
+        R[cn][ro->index] = 1;
+        O[cn][oo->index] = 1;
+
+        cn++;
+    }
 }
 
-void add3muladd3(element *oo, element *lo1, element *lo2, element *lo3, element *ro1, element *ro2, element *ro3)
+void add3muladd3(element* oo, element* lo1, element* lo2, element* lo3, element* ro1, element* ro2,
+                 element* ro3)
 {
-	if (setParams) N++;
-	else if (prover)
-	{
-		mclBnFr factor;
-		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
-		mclBnFr_add(&uw[oo->index], &uw[oo->index], &uw[lo3->index]);
-		mclBnFr_add(&factor, &uw[ro1->index], &uw[ro2->index]);
-		mclBnFr_add(&factor, &factor, &uw[ro3->index]);
-		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
-	}
-	else
-	{
-		L[cn][lo1->index] = 1;
-		L[cn][lo2->index] = 1;
-		L[cn][lo3->index] = 1;
-		R[cn][ro1->index] = 1;
-		R[cn][ro2->index] = 1;
-		R[cn][ro3->index] = 1;
-		O[cn][oo->index] = 1;
-
-		cn++;
-	}	
+    if (setParams)
+        N++;
+    else if (prover)
+    {
+        mclBnFr factor;
+        mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+        mclBnFr_add(&uw[oo->index], &uw[oo->index], &uw[lo3->index]);
+        mclBnFr_add(&factor, &uw[ro1->index], &uw[ro2->index]);
+        mclBnFr_add(&factor, &factor, &uw[ro3->index]);
+        mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
+    }
+    else
+    {
+        L[cn][lo1->index] = 1;
+        L[cn][lo2->index] = 1;
+        L[cn][lo3->index] = 1;
+        R[cn][ro1->index] = 1;
+        R[cn][ro2->index] = 1;
+        R[cn][ro3->index] = 1;
+        O[cn][oo->index] = 1;
+
+        cn++;
+    }
 }
 
-void addmuladd(element *oo, element *lo1, element *lo2, element *ro1, element *ro2)
+void addmuladd(element* oo, element* lo1, element* lo2, element* ro1, element* ro2)
 {
-	if (setParams) N++;
-	else if (prover)
-	{
-		mclBnFr factor;
-		mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
-		mclBnFr_add(&factor, &uw[ro1->index], &uw[ro2->index]);
-		mclBnFr_mul(&uw[oo->index], &factor, &uw[oo->index]);
-	}
-	else
-	{
-		L[cn][lo1->index] = 1;
-		L[cn][lo2->index] = 1;
-		R[cn][ro1->index] = 1;
-		R[cn][ro2->index] = 1;
-		O[cn][oo->index] = 1;
-
-		cn++;
-	}	
+    if (setParams)
+        N++;
+    else if (prover)
+    {
+        mclBnFr factor;
+        mclBnFr_add(&uw[oo->index], &uw[lo1->index], &uw[lo2->index]);
+        mclBnFr_add(&factor, &uw[ro1->index], &uw[ro2->index]);
+        mclBnFr_mul(&uw[oo->index], &factor, &uw[oo->index]);
+    }
+    else
+    {
+        L[cn][lo1->index] = 1;
+        L[cn][lo2->index] = 1;
+        R[cn][ro1->index] = 1;
+        R[cn][ro2->index] = 1;
+        O[cn][oo->index] = 1;
+
+        cn++;
+    }
 }
 
-void mul(element *oo, element *lo, element *ro)
-{	
-	if (setParams) N++;
-	else if (prover)
-	{
-		mclBnFr_mul(&uw[oo->index], &uw[lo->index], &uw[ro->index]);
-	}
-	else
-	{
-		L[cn][lo->index] = 1;
-		R[cn][ro->index] = 1;
-		O[cn][oo->index] = 1;
-
-		cn++;
-	}
+void mul(element* oo, element* lo, element* ro)
+{
+    if (setParams)
+        N++;
+    else if (prover)
+    {
+        mclBnFr_mul(&uw[oo->index], &uw[lo->index], &uw[ro->index]);
+    }
+    else
+    {
+        L[cn][lo->index] = 1;
+        R[cn][ro->index] = 1;
+        O[cn][oo->index] = 1;
+
+        cn++;
+    }
 }
 
-void addmul_constants(element *oo, int *lc1, element *lo1, int *lc2, element *lo2, int *rc, element *ro)
-{	
-	if (setParams) N++;
-	else if (prover)
-	{
-		mclBnFr factor, factor2;
-		mclBnFr_setInt(&factor, *lc1);
-		mclBnFr_mul(&factor, &uw[lo1->index], &factor);
-		mclBnFr_setInt(&factor2, *lc2);
-		mclBnFr_mul(&uw[oo->index], &uw[lo2->index], &factor2);
-		mclBnFr_add(&factor, &factor, &uw[oo->index]);
-		mclBnFr_setInt(&factor2, *rc);
-		mclBnFr_mul(&uw[oo->index], &uw[ro->index], &factor2);
-		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
-	}
-	else
-	{
-		L[cn][lo1->index] = *lc1;
-		L[cn][lo2->index] = *lc2;
-		R[cn][ro->index] = *rc;
-		O[cn][oo->index] = 1;
-
-		cn++;
-	}
+void addmul_constants(element* oo, int* lc1, element* lo1, int* lc2, element* lo2, int* rc,
+                      element* ro)
+{
+    if (setParams)
+        N++;
+    else if (prover)
+    {
+        mclBnFr factor, factor2;
+        mclBnFr_setInt(&factor, *lc1);
+        mclBnFr_mul(&factor, &uw[lo1->index], &factor);
+        mclBnFr_setInt(&factor2, *lc2);
+        mclBnFr_mul(&uw[oo->index], &uw[lo2->index], &factor2);
+        mclBnFr_add(&factor, &factor, &uw[oo->index]);
+        mclBnFr_setInt(&factor2, *rc);
+        mclBnFr_mul(&uw[oo->index], &uw[ro->index], &factor2);
+        mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
+    }
+    else
+    {
+        L[cn][lo1->index] = *lc1;
+        L[cn][lo2->index] = *lc2;
+        R[cn][ro->index] = *rc;
+        O[cn][oo->index] = 1;
+
+        cn++;
+    }
 }
 
-void mul_constants(element *oo, int *lc, element *lo, int *rc, element *ro)
-{	
-	if (setParams) N++;
-	else if (prover)
-	{
-		mclBnFr factor, factor2;
-		mclBnFr_setInt(&factor, *lc);
-		mclBnFr_mul(&factor, &uw[lo->index], &factor);
-		mclBnFr_setInt(&factor2, *rc);
-		mclBnFr_mul(&uw[oo->index], &uw[ro->index], &factor2);
-		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
-	}
-	else
-	{
-		L[cn][lo->index] = *lc;
-		R[cn][ro->index] = *rc;
-		O[cn][oo->index] = 1;
-
-		cn++;
-	}
+void mul_constants(element* oo, int* lc, element* lo, int* rc, element* ro)
+{
+    if (setParams)
+        N++;
+    else if (prover)
+    {
+        mclBnFr factor, factor2;
+        mclBnFr_setInt(&factor, *lc);
+        mclBnFr_mul(&factor, &uw[lo->index], &factor);
+        mclBnFr_setInt(&factor2, *rc);
+        mclBnFr_mul(&uw[oo->index], &uw[ro->index], &factor2);
+        mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
+    }
+    else
+    {
+        L[cn][lo->index] = *lc;
+        R[cn][ro->index] = *rc;
+        O[cn][oo->index] = 1;
+
+        cn++;
+    }
 }
 
-void mul_big_constants(element *oo, mclBnFr *lc, element *lo, mclBnFr *rc, element *ro)
-{	
-	if (setParams) 
-	{
-		lro_const_total += 2;
-		N++;
-	}
-	else if (prover)
-	{
-		mclBnFr factor;
-		mclBnFr_mul(&factor, &uw[lo->index], lc);
-		mclBnFr_mul(&uw[oo->index], &uw[ro->index], rc);
-		mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
-	}
-	else
-	{
-		L[cn][lo->index] = INT_MAX;
-		R[cn][ro->index] = INT_MAX;
-		O[cn][oo->index] = 1;
-
-		cn++;
-		mpz_t factor;
-		fr_to_mpz(&factor, lc);
-		mpz_set(LRO_constants[lro_constants_n], factor);
-		fr_to_mpz(&factor, rc);
-		mpz_set(LRO_constants[lro_constants_n + 1], factor);
-		lro_constants_n += 2;
-	}
+void mul_big_constants(element* oo, mclBnFr* lc, element* lo, mclBnFr* rc, element* ro)
+{
+    if (setParams)
+    {
+        lro_const_total += 2;
+        N++;
+    }
+    else if (prover)
+    {
+        mclBnFr factor;
+        mclBnFr_mul(&factor, &uw[lo->index], lc);
+        mclBnFr_mul(&uw[oo->index], &uw[ro->index], rc);
+        mclBnFr_mul(&uw[oo->index], &uw[oo->index], &factor);
+    }
+    else
+    {
+        L[cn][lo->index] = INT_MAX;
+        R[cn][ro->index] = INT_MAX;
+        O[cn][oo->index] = 1;
+
+        cn++;
+        mpz_t factor;
+        fr_to_mpz(&factor, lc);
+        mpz_set(LRO_constants[lro_constants_n], factor);
+        fr_to_mpz(&factor, rc);
+        mpz_set(LRO_constants[lro_constants_n + 1], factor);
+        lro_constants_n += 2;
+    }
 }
 
-void assert_equal(element *lo, element *ro)
+void assert_equal(element* lo, element* ro)
 {
-	element factor1, factor2;
-	init(&factor1);
-	init(&factor2);
+    element factor1, factor2;
+    init(&factor1);
+    init(&factor2);
 
-	mul(&factor1, ro, &oneNeg);
-	addmul0(&factor2, lo, &factor1, &one);
+    mul(&factor1, ro, &oneNeg);
+    addmul0(&factor2, lo, &factor1, &one);
 }
 
-void input(element *var, char *val)
+void input(element* var, char* val)
 {
-	if (!setParams) mclBnFr_setStr(&uw[var->index], val, strlen(val), 10);
+    if (!setParams)
+        mclBnFr_setStr(&uw[var->index], val, strlen(val), 10);
 }
 
-void init_constant(element *toAdd, char *val)
+void init_constant(element* toAdd, char* val)
 {
-	if (setParams) M++;
-	else
-	{
-		toAdd->index = constant_n;
-		constant_n++;
-		mclBnFr_setStr(&uw[toAdd->index], val, strlen(val), 10);
-	}
-	if (setParams) nConst++;
+    if (setParams)
+        M++;
+    else
+    {
+        toAdd->index = constant_n;
+        constant_n++;
+        mclBnFr_setStr(&uw[toAdd->index], val, strlen(val), 10);
+    }
+    if (setParams)
+        nConst++;
 }
 
-void init_public(element *toAdd)
+void init_public(element* toAdd)
 {
-	if (setParams) M++;
-	else
-	{
-		toAdd->index = un;
-		un++;
-	}
-	if (setParams) nPublic++;
+    if (setParams)
+        M++;
+    else
+    {
+        toAdd->index = un;
+        un++;
+    }
+    if (setParams)
+        nPublic++;
 }
 
-void init_array(element *toAdd, int size)
+void init_array(element* toAdd, int size)
 {
-	for (int i = 0; i < size; i++)
-	{
-		init(&toAdd[i]);
-	}
+    for (int i = 0; i < size; i++)
+    {
+        init(&toAdd[i]);
+    }
 }
 
-void init(element *toAdd)
+void init(element* toAdd)
 {
-	if (setParams) M++;
-	else
-	{
-		toAdd->index = wn;
-		wn++;
-	}
+    if (setParams)
+        M++;
+    else
+    {
+        toAdd->index = wn;
+        wn++;
+    }
 }
 
-void init_circuit(void *circuit)
+void init_circuit(void* circuit)
 {
-	init_constant(&one, "1");
-	init_constant(&oneNeg, "-1");
+    init_constant(&one, "1");
+    init_constant(&oneNeg, "-1");
 
-	char buff[2048];
-	FILE *cnst;
-	cnst = fopen("circuits/constants.txt", "r");
+    char buff[2048];
+    FILE* cnst;
+    cnst = fopen("circuits/constants.txt", "r");
 
-	for (int i = 0; i < 91; i++)
-	{
-		fgets(buff, sizeof buff, cnst);
-		init_constant(&c_mimc[i], buff);
-	}
+    for (int i = 0; i < 91; i++)
+    {
+        fgets(buff, sizeof buff, cnst);
+        init_constant(&c_mimc[i], buff);
+    }
 
-	fclose(cnst);
+    fclose(cnst);
 
-	((void(*)(void))circuit)();
+    ((void (*)(void)) circuit)();
 }
 
 void test_full_api()
 {
-	element e_mul, e_addmul, e_add3mul, e_addmuladd;
+    element e_mul, e_addmul, e_add3mul, e_addmuladd;
     init(&e_mul);
-	init(&e_addmul);
-	init(&e_add3mul);
-	init(&e_addmuladd);
+    init(&e_addmul);
+    init(&e_add3mul);
+    init(&e_addmuladd);
 
     element a, b;
     init(&a);
@@ -323,37 +340,37 @@ void test_full_api()
     input(&b, "10");
 
     mul(&e_mul, &a, &b);
-	addmul(&e_addmul, &a, &b, &b);
-	add3mul(&e_add3mul, &a, &a, &a, &b);
-	addmuladd(&e_addmuladd, &a, &a, &b, &b);
+    addmul(&e_addmul, &a, &b, &b);
+    add3mul(&e_add3mul, &a, &a, &a, &b);
+    addmuladd(&e_addmuladd, &a, &a, &b, &b);
 }
 
 void test_constraint_system(void)
 {
-	uw = (mclBnFr*) malloc((99) * sizeof(mclBnFr));
-	wn = nPublic + nConst;
-	un = nConst;
-	constant_n = 0;
-	lro_constants_n = 0;
-	lro_const_total = 0;
+    uw = (mclBnFr*) malloc((99) * sizeof(mclBnFr));
+    wn = nPublic + nConst;
+    un = nConst;
+    constant_n = 0;
+    lro_constants_n = 0;
+    lro_const_total = 0;
 
     for (int i = 0; i < 99; i++)
     {
         mclBnFr_clear(&uw[i]);
     }
 
-	prover = 1;
-	init_circuit(&test_full_api);
-	prover = 0;
+    prover = 1;
+    init_circuit(&test_full_api);
+    prover = 0;
 
-	mclBnFr equal;
-	mclBnFr_setInt(&equal, 50);
-	CU_ASSERT(mclBnFr_isEqual(&uw[nConst], &equal));
+    mclBnFr equal;
+    mclBnFr_setInt(&equal, 50);
+    CU_ASSERT(mclBnFr_isEqual(&uw[nConst], &equal));
 
-	mclBnFr_setInt(&equal, 150);
-	CU_ASSERT(mclBnFr_isEqual(&uw[1+nConst], &equal));
-	CU_ASSERT(mclBnFr_isEqual(&uw[2+nConst], &equal));
+    mclBnFr_setInt(&equal, 150);
+    CU_ASSERT(mclBnFr_isEqual(&uw[1 + nConst], &equal));
+    CU_ASSERT(mclBnFr_isEqual(&uw[2 + nConst], &equal));
 
-	mclBnFr_setInt(&equal, 200);
-	CU_ASSERT(mclBnFr_isEqual(&uw[3+nConst], &equal));
+    mclBnFr_setInt(&equal, 200);
+    CU_ASSERT(mclBnFr_isEqual(&uw[3 + nConst], &equal));
 }
\ No newline at end of file
diff --git a/src/gro16/prover.c b/src/gro16/prover.c
index 39d0c66..a8989e2 100644
--- a/src/gro16/prover.c
+++ b/src/gro16/prover.c
@@ -1,9 +1,9 @@
 
-void h_coefficients(proving_key *pk)
+void h_coefficients(proving_key* pk)
 {
     int n = mpz_get_ui(pk->Ne);
 
-    #pragma omp parallel for
+#pragma omp parallel for
     for (int j = 0; j < n; j++)
     {
         mclBnFr_clear(&AsFr[j]);
@@ -14,68 +14,80 @@ void h_coefficients(proving_key *pk)
     int l_it = 0;
     int r_it = 1;
 
-    for (int j = 0; j < pk->qap_size; j+=3)
+    for (int j = 0; j < pk->qap_size; j += 3)
     {
         switch (pk->LRO[j])
         {
-            case 1: mclBnFr_add(&AsFr[pk->LRO[j+1]], &AsFr[pk->LRO[j+1]], &uw[pk->LRO[j+2]]); break;
-            case 2: mclBnFr_add(&BsFr[pk->LRO[j+1]], &BsFr[pk->LRO[j+1]], &uw[pk->LRO[j+2]]); break;
-            case 3: mclBnFr_add(&CsFr[pk->LRO[j+1]], &CsFr[pk->LRO[j+1]], &uw[pk->LRO[j+2]]); break;
-            case 10:
+        case 1:
+            mclBnFr_add(&AsFr[pk->LRO[j + 1]], &AsFr[pk->LRO[j + 1]], &uw[pk->LRO[j + 2]]);
+            break;
+        case 2:
+            mclBnFr_add(&BsFr[pk->LRO[j + 1]], &BsFr[pk->LRO[j + 1]], &uw[pk->LRO[j + 2]]);
+            break;
+        case 3:
+            mclBnFr_add(&CsFr[pk->LRO[j + 1]], &CsFr[pk->LRO[j + 1]], &uw[pk->LRO[j + 2]]);
+            break;
+        case 10:
+        {
+            mclBnFr factorFr;
+            if (pk->LRO[j + 3] != INT_MAX)
             {
-                mclBnFr factorFr;
-                if (pk->LRO[j+3] != INT_MAX)
-                {
-                    mclBnFr_setInt(&factorFr, pk->LRO[j+3]);
-                    mclBnFr_mul(&factorFr, &uw[pk->LRO[j+2]], &factorFr);
-                }
-                else
-                {
-                    mclBnFr_mul(&factorFr, &uw[pk->LRO[j+2]], &pk->LRO_constants[l_it]);
-                    l_it+=2;
-                }
-                mclBnFr_add(&AsFr[pk->LRO[j+1]], &AsFr[pk->LRO[j+1]], &factorFr); 
-                j+=1;
-                break;
+                mclBnFr_setInt(&factorFr, pk->LRO[j + 3]);
+                mclBnFr_mul(&factorFr, &uw[pk->LRO[j + 2]], &factorFr);
             }
-            case 20:
+            else
             {
-                mclBnFr factorFr;
-                if (pk->LRO[j+3] != INT_MAX)
-                {
-                    mclBnFr_setInt(&factorFr, pk->LRO[j+3]);
-                    mclBnFr_mul(&factorFr, &uw[pk->LRO[j+2]], &factorFr);
-                }
-                else
-                {
-                    mclBnFr_mul(&factorFr, &uw[pk->LRO[j+2]], &pk->LRO_constants[r_it]);
-                    r_it+=2;
-                }
-                mclBnFr_add(&BsFr[pk->LRO[j+1]], &BsFr[pk->LRO[j+1]], &factorFr);
-                j+=1; 
-                break;
+                mclBnFr_mul(&factorFr, &uw[pk->LRO[j + 2]], &pk->LRO_constants[l_it]);
+                l_it += 2;
             }
+            mclBnFr_add(&AsFr[pk->LRO[j + 1]], &AsFr[pk->LRO[j + 1]], &factorFr);
+            j += 1;
+            break;
+        }
+        case 20:
+        {
+            mclBnFr factorFr;
+            if (pk->LRO[j + 3] != INT_MAX)
+            {
+                mclBnFr_setInt(&factorFr, pk->LRO[j + 3]);
+                mclBnFr_mul(&factorFr, &uw[pk->LRO[j + 2]], &factorFr);
+            }
+            else
+            {
+                mclBnFr_mul(&factorFr, &uw[pk->LRO[j + 2]], &pk->LRO_constants[r_it]);
+                r_it += 2;
+            }
+            mclBnFr_add(&BsFr[pk->LRO[j + 1]], &BsFr[pk->LRO[j + 1]], &factorFr);
+            j += 1;
+            break;
+        }
         }
     }
 
-    #pragma omp parallel num_threads(3)
+#pragma omp parallel num_threads(3)
     {
         switch (get_thread())
         {
-            case 0: ifft_t(n, pk->wM, AsFr); break;
-            case 1: ifft_t(n, pk->wM, BsFr); break;
-            case 2: ifft_t(n, pk->wM, CsFr); break;
-            case 99:
-                ifft_t(n, pk->wM, AsFr);
-                ifft_t(n, pk->wM, BsFr);
-                ifft_t(n, pk->wM, CsFr);
-                break;
+        case 0:
+            ifft_t(n, pk->wM, AsFr);
+            break;
+        case 1:
+            ifft_t(n, pk->wM, BsFr);
+            break;
+        case 2:
+            ifft_t(n, pk->wM, CsFr);
+            break;
+        case 99:
+            ifft_t(n, pk->wM, AsFr);
+            ifft_t(n, pk->wM, BsFr);
+            ifft_t(n, pk->wM, CsFr);
+            break;
         }
     }
 
-    #pragma omp parallel for
+#pragma omp parallel for
     for (int i = 0; i < n; i++)
-    {       
+    {
         mclBnFr_mul(&AsFr[i], &AsFr[i], &BsFr[i]);
         mclBnFr_sub(&AsFr[i], &AsFr[i], &CsFr[i]);
     }
@@ -83,29 +95,31 @@ void h_coefficients(proving_key *pk)
     ifft(n, pk->wM, AsFr);
 }
 
-void mul_exp(struct mulExpResult *result, mclBnFr *uwProof, proving_key *pk)
+void mul_exp(struct mulExpResult* result, mclBnFr* uwProof, proving_key* pk)
 {
     int n = mpz_get_ui(pk->Ne);
 
     for (int i = nConst; i < (nPublic + nConst); i++)
     {
-        uwProof[i-nConst] = uw[i];
+        uwProof[i - nConst] = uw[i];
     }
 
-    #ifdef IS_MAC_OS
-        int num_threads = 8;
-    #else
-        int num_threads = get_nprocs();
-    #endif
+#ifdef IS_MAC_OS
+    int num_threads = 8;
+#else
+    int num_threads = get_nprocs();
+#endif
 
     mclBnG1_mulVecMT(&result->uwA1, pk->A1, uw, M, num_threads);
     mclBnG1_mulVecMT(&result->uwB1, pk->B1, uw, M, num_threads);
     mclBnG2_mulVecMT(&result->uwB2, pk->B2, uw, M, num_threads);
-    mclBnG1_mulVecMT(&result->uwC1, pk->pk1, uw + nPublic + nConst, M-(nPublic + nConst), num_threads);
+    mclBnG1_mulVecMT(&result->uwC1, pk->pk1, uw + nPublic + nConst, M - (nPublic + nConst),
+                     num_threads);
     mclBnG1_mulVecMT(&result->htdelta, pk->xt1_rand, AsFr, n, num_threads);
 }
 
-void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mclBnFr *uwProof, proving_key *pk)
+void prove(int* circuit, mclBnG1* piA, mclBnG2* piB2, mclBnG1* piC, mclBnFr* uwProof,
+           proving_key* pk)
 {
     prover = 1;
 
@@ -118,7 +132,8 @@ void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mclBnFr *uwP
     clock_gettime(CLOCK_MONOTONIC, &end);
     elapsed = (end.tv_sec - begin.tv_sec);
     elapsed += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
-    if (bench) printf("  |--- Circuit evaluation:  [%fs]\n", elapsed);
+    if (bench)
+        printf("  |--- Circuit evaluation:  [%fs]\n", elapsed);
 
     prover = 0;
 
@@ -129,7 +144,8 @@ void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mclBnFr *uwP
     clock_gettime(CLOCK_MONOTONIC, &end);
     elapsed = (end.tv_sec - begin.tv_sec);
     elapsed += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
-    if (bench) printf("  |--- Compute h coefficients:  [%fs]\n", elapsed);
+    if (bench)
+        printf("  |--- Compute h coefficients:  [%fs]\n", elapsed);
 
     clock_gettime(CLOCK_MONOTONIC, &begin);
 
@@ -140,7 +156,8 @@ void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mclBnFr *uwP
     elapsed = (end.tv_sec - begin.tv_sec);
     elapsed += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
 
-    if (bench) printf("  |--- G1, G2 multiexponentiations:  [%fs]\n", elapsed);
+    if (bench)
+        printf("  |--- G1, G2 multiexponentiations:  [%fs]\n", elapsed);
     log_message("Computing piA, piB1, piB2, piC, htdelta...");
 
     mclBnG1 piB1;
@@ -176,7 +193,7 @@ void prove(int *circuit, mclBnG1 *piA, mclBnG2 *piB2, mclBnG1 *piC, mclBnFr *uwP
     mclBnG1_add(piC, piC, &result.uwC1);
 
     log_state(1);
-    if (logs) 
+    if (logs)
     {
         char buff[2048];
 
diff --git a/src/gro16/qap.c b/src/gro16/qap.c
index 06049af..d8c09ad 100644
--- a/src/gro16/qap.c
+++ b/src/gro16/qap.c
@@ -1,7 +1,8 @@
 
-void generateqap(void *circuit, mpz_t *A, mpz_t *B, mpz_t *C, struct Trapdoor t, int *qap_size, mpz_t *Ne)
+void generateqap(void* circuit, mpz_t* A, mpz_t* B, mpz_t* C, struct Trapdoor t, int* qap_size,
+                 mpz_t* Ne)
 {
-    #pragma omp parallel for
+#pragma omp parallel for
     for (int i = 0; i < M; i++)
     {
         mpz_init(A[i]);
@@ -9,9 +10,9 @@ void generateqap(void *circuit, mpz_t *A, mpz_t *B, mpz_t *C, struct Trapdoor t,
         mpz_init(C[i]);
     }
 
-    L = (int **)malloc(N * sizeof(int*));
-    R = (int **)malloc(N * sizeof(int*));
-    O = (int **)malloc(N * sizeof(int*));
+    L = (int**) malloc(N * sizeof(int*));
+    R = (int**) malloc(N * sizeof(int*));
+    O = (int**) malloc(N * sizeof(int*));
 
     for (int i = 0; i < N; i++)
     {
@@ -34,7 +35,7 @@ void generateqap(void *circuit, mpz_t *A, mpz_t *B, mpz_t *C, struct Trapdoor t,
     wn = nPublic + nConst;
     un = nConst;
     constant_n = 0;
-    init_circuit(circuit); 
+    init_circuit(circuit);
     log_state(1);
 
     if (logs)
@@ -87,7 +88,7 @@ void generateqap(void *circuit, mpz_t *A, mpz_t *B, mpz_t *C, struct Trapdoor t,
     mpz_mul(uL, T, uL); // L1 = Zs / d
     mpz_mod(uL, uL, pPrime);
 
-    mpz_t *u = (mpz_t*) malloc((N) * sizeof(mpz_t));
+    mpz_t* u = (mpz_t*) malloc((N) * sizeof(mpz_t));
 
     for (int i = 0; i < N; i++)
     {
@@ -102,28 +103,30 @@ void generateqap(void *circuit, mpz_t *A, mpz_t *B, mpz_t *C, struct Trapdoor t,
         mpz_mod(uL, uL, pPrime);
     }
 
-    int l_it = lro_const_total-2;
-    int r_it = lro_const_total-1;
-    
+    int l_it = lro_const_total - 2;
+    int r_it = lro_const_total - 1;
+
     for (int j = N; j--;)
     {
         for (int i = M; i--;)
         {
             mpz_t factor;
             mpz_init(factor);
-            if (L[j][i] != INT_MAX) mpz_mul_si(factor, u[j], L[j][i]);
-            else 
+            if (L[j][i] != INT_MAX)
+                mpz_mul_si(factor, u[j], L[j][i]);
+            else
             {
                 mpz_mul(factor, u[j], LRO_constants[l_it]);
-                l_it-=2;
+                l_it -= 2;
             }
             mpz_add(A[i], A[i], factor);
             mpz_mod(A[i], A[i], pPrime);
-            if (R[j][i] != INT_MAX) mpz_mul_si(factor, u[j], R[j][i]);
-            else 
+            if (R[j][i] != INT_MAX)
+                mpz_mul_si(factor, u[j], R[j][i]);
+            else
             {
                 mpz_mul(factor, u[j], LRO_constants[r_it]);
-                r_it-=2;
+                r_it -= 2;
             }
             mpz_add(B[i], B[i], factor);
             mpz_mod(B[i], B[i], pPrime);
@@ -131,18 +134,23 @@ void generateqap(void *circuit, mpz_t *A, mpz_t *B, mpz_t *C, struct Trapdoor t,
             mpz_mod(C[i], C[i], pPrime);
         }
     }
-    
+
     *qap_size = 0;
     for (int i = 0; i < M; i++)
     {
         for (int j = 0; j < N; j++)
         {
-            if (L[j][i] == 1) *qap_size += 3;
-            else if (L[j][i] != 0) *qap_size += 4;
-            if (R[j][i] == 1) *qap_size += 3;
-            else if (R[j][i] != 0) *qap_size += 4;
-            
-            if (O[j][i]) *qap_size += 3;
+            if (L[j][i] == 1)
+                *qap_size += 3;
+            else if (L[j][i] != 0)
+                *qap_size += 4;
+            if (R[j][i] == 1)
+                *qap_size += 3;
+            else if (R[j][i] != 0)
+                *qap_size += 4;
+
+            if (O[j][i])
+                *qap_size += 3;
         }
     }
 }
\ No newline at end of file
diff --git a/src/gro16/setup.c b/src/gro16/setup.c
index 328054b..205af48 100644
--- a/src/gro16/setup.c
+++ b/src/gro16/setup.c
@@ -1,8 +1,9 @@
-void setup(void *circuit, struct Trapdoor *t, struct Sigma1 *s1, struct Sigma2 *s2, mclBnGT *alphabetaT, int *qap_size, mpz_t *Ne)
+void setup(void* circuit, struct Trapdoor* t, struct Sigma1* s1, struct Sigma2* s2,
+           mclBnGT* alphabetaT, int* qap_size, mpz_t* Ne)
 {
-    mpz_t *A = (mpz_t*) malloc((M) * sizeof(mpz_t));
-    mpz_t *B = (mpz_t*) malloc((M) * sizeof(mpz_t));
-    mpz_t *C = (mpz_t*) malloc((M) * sizeof(mpz_t));
+    mpz_t* A = (mpz_t*) malloc((M) * sizeof(mpz_t));
+    mpz_t* B = (mpz_t*) malloc((M) * sizeof(mpz_t));
+    mpz_t* C = (mpz_t*) malloc((M) * sizeof(mpz_t));
 
     mclBnG1 g;
     mclBnG2 h; // generators for G1 and G2
@@ -38,7 +39,7 @@ void setup(void *circuit, struct Trapdoor *t, struct Sigma1 *s1, struct Sigma2 *
     mpz_sub(T, T, factor);
 
     // encrypt
-    mclBnFr *frFactor = (mclBnFr*) malloc((M) * sizeof(mclBnFr));
+    mclBnFr* frFactor = (mclBnFr*) malloc((M) * sizeof(mclBnFr));
     mpz_to_fr(&frFactor[0], &t->alpha);
     mclBnG1_mul(&s1->alpha, &g, &frFactor[0]);
     mpz_to_fr(&frFactor[0], &t->beta);
@@ -51,7 +52,7 @@ void setup(void *circuit, struct Trapdoor *t, struct Sigma1 *s1, struct Sigma2 *
     mpz_invert(invGamma, t->gamma, pPrime);
     mpz_invert(invDelta, t->delta, pPrime);
 
-    #pragma omp parallel for
+#pragma omp parallel for
     for (int i = 0; i < M; i++)
     {
         mpz_to_fr(&frFactor[i], &A[i]);
@@ -60,7 +61,7 @@ void setup(void *circuit, struct Trapdoor *t, struct Sigma1 *s1, struct Sigma2 *
         mclBnG1_mul(&s1->B[i], &g, &frFactor[i]);
     }
 
-    #pragma omp parallel for
+#pragma omp parallel for
     for (int i = 0; i < (nPublic + nConst); i++)
     {
         mpz_t f;
@@ -78,17 +79,17 @@ void setup(void *circuit, struct Trapdoor *t, struct Sigma1 *s1, struct Sigma2 *
         mclBnG1_mul(&s1->vk[i], &g, &frFactor[i]);
     }
 
-    #pragma omp parallel for
-    for (int i = 0; i < M-(nPublic + nConst); i++)
+#pragma omp parallel for
+    for (int i = 0; i < M - (nPublic + nConst); i++)
     {
         mpz_t f;
         mpz_init(f);
         // (t->beta * A[i] + t->alpha * B[i] + C[i]) * invDelta
-        mpz_mul(f, t->beta, A[i+(nPublic + nConst)]);
+        mpz_mul(f, t->beta, A[i + (nPublic + nConst)]);
         mpz_mod(f, f, pPrime);
-        mpz_addmul(f, t->alpha, B[i+(nPublic + nConst)]);
+        mpz_addmul(f, t->alpha, B[i + (nPublic + nConst)]);
         mpz_mod(f, f, pPrime);
-        mpz_add(f, f, C[i+(nPublic + nConst)]);
+        mpz_add(f, f, C[i + (nPublic + nConst)]);
         mpz_mul(f, f, invDelta);
         mpz_mod(f, f, pPrime);
         mpz_to_fr(&frFactor[i], &f);
@@ -101,7 +102,7 @@ void setup(void *circuit, struct Trapdoor *t, struct Sigma1 *s1, struct Sigma2 *
     mpz_mod(zod, zod, pPrime);
 
     int n = mpz_get_ui(*Ne);
-    mclBnFr *frFactor2 = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
+    mclBnFr* frFactor2 = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
 
     mpz_to_fr(&frFactor2[0], &zod);
     mclBnG1_mul(&s1->xt[0], &g, &frFactor2[0]);
@@ -125,7 +126,7 @@ void setup(void *circuit, struct Trapdoor *t, struct Sigma1 *s1, struct Sigma2 *
     mpz_to_fr(&frFactor[0], &t->delta);
     mclBnG2_mul(&s2->delta, &h, &frFactor[0]);
 
-    #pragma omp parallel for
+#pragma omp parallel for
     for (int i = 0; i < M; i++)
     {
         mpz_to_fr(&frFactor[i], &B[i]);
@@ -133,8 +134,8 @@ void setup(void *circuit, struct Trapdoor *t, struct Sigma1 *s1, struct Sigma2 *
     }
 
     mclBn_pairing(alphabetaT, &s1->alpha, &s2->beta);
-    
-    #pragma omp parallel for
+
+#pragma omp parallel for
     for (int i = 0; i < M; i++)
     {
         mpz_clear(A[i]);
diff --git a/src/gro16/verifier.c b/src/gro16/verifier.c
index 017f122..11b084c 100644
--- a/src/gro16/verifier.c
+++ b/src/gro16/verifier.c
@@ -1,5 +1,5 @@
 
-int verify(proof *p, verifying_key *vk)
+int verify(proof* p, verifying_key* vk)
 {
     mclBnG1 factorG1;
     mclBnFr frFactor;
@@ -10,7 +10,7 @@ int verify(proof *p, verifying_key *vk)
     for (int i = (nPublic); i--;)
     {
         // Vu = Vu + u[i] * s1.vk[i]
-        mclBnG1_mul(&factorG1, &vk->vk1[i+nConst], &p->uwProof[i]);
+        mclBnG1_mul(&factorG1, &vk->vk1[i + nConst], &p->uwProof[i]);
         mclBnG1_add(&Vu, &Vu, &factorG1);
     }
 
@@ -23,18 +23,24 @@ int verify(proof *p, verifying_key *vk)
 
     log_message("Computing e(piA, piB2), e(Vu, gamma), e(piC, delta)...");
 
-    #pragma omp parallel num_threads(3)
+#pragma omp parallel num_threads(3)
     {
         switch (get_thread())
         {
-            case 0: mclBn_pairing(&pairing1, &p->piA, &p->piB2); break;
-            case 1: mclBn_pairing(&pairing2, &Vu, &vk->gamma2); break;
-            case 2: mclBn_pairing(&pairing3, &p->piC, &vk->delta2); break;
-            case 99:
-                mclBn_pairing(&pairing1, &p->piA, &p->piB2);
-                mclBn_pairing(&pairing2, &Vu, &vk->gamma2);
-                mclBn_pairing(&pairing3, &p->piC, &vk->delta2);
-                break;
+        case 0:
+            mclBn_pairing(&pairing1, &p->piA, &p->piB2);
+            break;
+        case 1:
+            mclBn_pairing(&pairing2, &Vu, &vk->gamma2);
+            break;
+        case 2:
+            mclBn_pairing(&pairing3, &p->piC, &vk->delta2);
+            break;
+        case 99:
+            mclBn_pairing(&pairing1, &p->piA, &p->piB2);
+            mclBn_pairing(&pairing2, &Vu, &vk->gamma2);
+            mclBn_pairing(&pairing3, &p->piC, &vk->delta2);
+            break;
         }
     }
 
@@ -61,13 +67,16 @@ int verify(proof *p, verifying_key *vk)
     }
 
     log_message("e(piA, piB2) = e(alpha, beta) * e(Vu, gamma) * e(piC, delta)???");
-    
+
     int verified = mclBnGT_isEqual(&pairing1, &factorGT);
 
-    if (mclBnGT_isOne(&pairing2)) verified = 0;
-    
-    if (verified) log_state(1);
-    else log_state(0);
-    
+    if (mclBnGT_isOne(&pairing2))
+        verified = 0;
+
+    if (verified)
+        log_state(1);
+    else
+        log_state(0);
+
     return verified;
 }
\ No newline at end of file
diff --git a/src/tests.c b/src/tests.c
index ea0348f..fd8945f 100644
--- a/src/tests.c
+++ b/src/tests.c
@@ -1,7 +1,7 @@
 #include "zpie.h"
 
-#include "../circuits/mimc.c"
 #include "../circuits/eddsa.c"
+#include "../circuits/mimc.c"
 
 void test_single_constraint()
 {
@@ -23,9 +23,9 @@ void test_eddsa_verification()
     point B;
     B.x = "5299619240641551281634865583518297030282874472190772894086521144482721001553";
     B.y = "16950150798460657717958625567821834550301663161624707787222815936182638968203";
-    
+
     eddsa_signature edsig;
-    edsig.R.x = "1262948111445225057373438194818763405700457487429548371463214326190311895864"; 
+    edsig.R.x = "1262948111445225057373438194818763405700457487429548371463214326190311895864";
     edsig.R.y = "12533500305127747239777484416561675628195562065959201739446841668623540883587";
     edsig.S = "2674591880888862378688383832785447197125897205360861957116147165712709455207";
 
@@ -33,7 +33,7 @@ void test_eddsa_verification()
     A.x = "21629779320182474195265732521833299809982444552305142529409236301104997786342";
     A.y = "9011812445381030664142622066218331845140881847034934166630871421746105699091";
 
-    char *msg = "1234";
+    char* msg = "1234";
 
     verify_eddsa(edsig, B, A, msg);
 }
@@ -45,7 +45,7 @@ void test_mimc_hash()
     init_public(&h);
     init(&x_in);
     init(&k);
-    
+
     input(&x_in, "1234");
     input(&k, "112233445566");
 
@@ -55,12 +55,20 @@ void test_mimc_hash()
 void test_prover(void)
 {
     test_no_rand = 1;
-    setup_keys keys = perform_setup(&test_single_constraint); 
+    setup_keys keys = perform_setup(&test_single_constraint);
     proof p = generate_proof(&test_single_constraint, &keys.pk);
 
-    const char *piAstr = "1 13398732126763033363928255770670403609664455533535809960659793057603927642327 14567332642717250669329472598965177550050834309459245026995104363234319745805";
-    const char *piB2str = "1 9513526328373247288214002967710658327692956864193416721895179753121227228903 17320346092699268035923233491595138958007151833266586455159840335219170425243 8079768110185479532548096263199181437927983909022782182442306192699700743609 19381997603489315175356927627025590277145986935796790438444340629346184509934";
-    const char *piCstr = "1 6751941069502688487334371509286578067074020223942252322110100779175835131489 10460091663676025417104943726359531715081933829156881875323036992094404259688";
+    const char* piAstr =
+        "1 13398732126763033363928255770670403609664455533535809960659793057603927642327 "
+        "14567332642717250669329472598965177550050834309459245026995104363234319745805";
+    const char* piB2str =
+        "1 9513526328373247288214002967710658327692956864193416721895179753121227228903 "
+        "17320346092699268035923233491595138958007151833266586455159840335219170425243 "
+        "8079768110185479532548096263199181437927983909022782182442306192699700743609 "
+        "19381997603489315175356927627025590277145986935796790438444340629346184509934";
+    const char* piCstr =
+        "1 6751941069502688487334371509286578067074020223942252322110100779175835131489 "
+        "10460091663676025417104943726359531715081933829156881875323036992094404259688";
 
     mclBnG1 piA, piC;
     mclBnG2 piB2;
@@ -78,47 +86,50 @@ void test_prover(void)
 
 void test_full_circuits(void)
 {
-    setup_keys keys_sc = perform_setup(&test_single_constraint); 
-    setup_keys keys_mh = perform_setup(&test_mimc_hash);  
-    setup_keys keys_ev = perform_setup(&test_eddsa_verification); 
+    setup_keys keys_sc = perform_setup(&test_single_constraint);
+    setup_keys keys_mh = perform_setup(&test_mimc_hash);
+    setup_keys keys_ev = perform_setup(&test_eddsa_verification);
 
     proof p_sc = generate_proof(&test_single_constraint, &keys_sc.pk);
     proof p_mh = generate_proof(&test_mimc_hash, &keys_mh.pk);
     proof p_ev = generate_proof(&test_eddsa_verification, &keys_ev.pk);
-    
+
     CU_ASSERT(verify_proof(&test_single_constraint, &p_sc, &keys_sc.vk));
     CU_ASSERT(verify_proof(&test_mimc_hash, &p_mh, &keys_mh.vk));
     CU_ASSERT(verify_proof(&test_eddsa_verification, &p_ev, &keys_ev.vk));
 }
 
-//TODO: fix this
+// TODO: fix this
 void test_bulletproofs(void)
 {
     // we init the bulletproofs module, for 2 aggregated proofs of 64 bits
-    //bulletproof_init(64, 2);
+    // bulletproof_init(64, 2);
 
     // we set some values to prove knowledge of, and compute the proof (../data/bulletproof.params)
-    //unsigned char *si[] = {"1234", "5678"};
-    //bulletproof_prove(si);
+    // unsigned char *si[] = {"1234", "5678"};
+    // bulletproof_prove(si);
 
     // we verify the bulletproof (../data/bulletproof.params)
-    //if(bulletproof_verify()) printf("Bulletproof verified.\n");
-    //else printf("Bulletproof cannot be verified.\n");
+    // if(bulletproof_verify()) printf("Bulletproof verified.\n");
+    // else printf("Bulletproof cannot be verified.\n");
 }
 
 int main()
 {
     CU_pSuite suite = NULL;
-    if (CUE_SUCCESS != CU_initialize_registry()) return CU_get_error();
+    if (CUE_SUCCESS != CU_initialize_registry())
+        return CU_get_error();
     suite = CU_add_suite("Test Suite", init_suite, clean_suite);
 
-    if ((NULL == suite) || (NULL == CU_add_test(suite, "\n\nFull Circuits Testing\n\n", test_full_circuits)))
+    if ((NULL == suite) ||
+        (NULL == CU_add_test(suite, "\n\nFull Circuits Testing\n\n", test_full_circuits)))
     {
         CU_cleanup_registry();
         return CU_get_error();
     }
 
-    if ((NULL == suite) || (NULL == CU_add_test(suite, "\n\nConstraint System Testing\n\n", test_constraint_system)))
+    if ((NULL == suite) ||
+        (NULL == CU_add_test(suite, "\n\nConstraint System Testing\n\n", test_constraint_system)))
     {
         CU_cleanup_registry();
         return CU_get_error();
@@ -131,7 +142,8 @@ int main()
     }
 
     CU_basic_run_tests();
-    if(CU_get_number_of_failures()) abort();
+    if (CU_get_number_of_failures())
+        abort();
 
     CU_cleanup_registry();
     return CU_get_error();
diff --git a/src/zpie.c b/src/zpie.c
index 088580f..b54cd00 100644
--- a/src/zpie.c
+++ b/src/zpie.c
@@ -1,8 +1,8 @@
 
-setup_keys perform_setup(void *circuit)
+setup_keys perform_setup(void* circuit)
 {
     init_setup(circuit);
-    
+
     struct Trapdoor t; // to be destroyed
 
     struct Sigma1 s1;
@@ -29,7 +29,7 @@ setup_keys perform_setup(void *circuit)
     mpz_t base, w;
     mpz_init(w);
     mpz_init(base);
-    mpz_init_set_ui(base, GROUPGEN); // multiplicative group generator  
+    mpz_init_set_ui(base, GROUPGEN); // multiplicative group generator
     mpz_powm(w, base, kmul, pPrime);
 
     int n = mpz_get_ui(Ne);
@@ -46,7 +46,7 @@ setup_keys perform_setup(void *circuit)
     s1.A = (mclBnG1*) malloc((M) * sizeof(mclBnG1));
     s1.B = (mclBnG1*) malloc((M) * sizeof(mclBnG1));
     s1.vk = (mclBnG1*) malloc(((nPublic + nConst)) * sizeof(mclBnG1));
-    s1.pk = (mclBnG1*) malloc((M-(nPublic + nConst)) * sizeof(mclBnG1));
+    s1.pk = (mclBnG1*) malloc((M - (nPublic + nConst)) * sizeof(mclBnG1));
     s2.B = (mclBnG2*) malloc((M) * sizeof(mclBnG2));
 
     for (int i = 0; i < n; i++)
@@ -75,46 +75,46 @@ setup_keys perform_setup(void *circuit)
     {
         for (int j = 0; j < N; j++)
         {
-            if(L[j][i] != 0) 
+            if (L[j][i] != 0)
             {
-                keys.pk.LRO[it+1] = j;
-                keys.pk.LRO[it+2] = i;
+                keys.pk.LRO[it + 1] = j;
+                keys.pk.LRO[it + 2] = i;
 
                 if (L[j][i] != 1)
                 {
                     keys.pk.LRO[it] = 10;
-                    keys.pk.LRO[it+3] = L[j][i];
-                    it+=4;
+                    keys.pk.LRO[it + 3] = L[j][i];
+                    it += 4;
                 }
                 else
                 {
                     keys.pk.LRO[it] = 1;
-                    it+=3;
+                    it += 3;
                 }
             }
-            if(R[j][i] != 0) 
+            if (R[j][i] != 0)
             {
-                keys.pk.LRO[it+1] = j;
-                keys.pk.LRO[it+2] = i;
+                keys.pk.LRO[it + 1] = j;
+                keys.pk.LRO[it + 2] = i;
 
                 if (R[j][i] != 1)
                 {
                     keys.pk.LRO[it] = 20;
-                    keys.pk.LRO[it+3] = R[j][i];
-                    it+=4;
+                    keys.pk.LRO[it + 3] = R[j][i];
+                    it += 4;
                 }
-                else 
+                else
                 {
                     keys.pk.LRO[it] = 2;
-                    it+=3;
+                    it += 3;
                 }
             }
-            if(O[j][i]) 
+            if (O[j][i])
             {
                 keys.pk.LRO[it] = 3;
-                keys.pk.LRO[it+1] = j;
-                keys.pk.LRO[it+2] = i;
-                it+=3;
+                keys.pk.LRO[it + 1] = j;
+                keys.pk.LRO[it + 2] = i;
+                it += 3;
             }
         }
     }
@@ -153,19 +153,21 @@ setup_keys perform_setup(void *circuit)
     elapsed += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
 
     log_success("Setup generated successfully in", 1);
-    if (bench) printf(" %fs\n", elapsed);
+    if (bench)
+        printf(" %fs\n", elapsed);
 
     return keys;
 }
 
-void serialize_pk(proving_key *pk)
+void serialize_pk(proving_key* pk)
 {
-    FILE *fpk;
+    FILE* fpk;
     fpk = fopen("data/provingkey.params", "w");
 
     int n = mpz_get_ui(pk->Ne);
 
-    int buff_pk_size = SIZE_FR * (n + lro_const_total) + SIZE_G2 * (2 + M) + SIZE_G1 * (M - (nPublic + nConst) + 3 + n + 2 * M);
+    int buff_pk_size = SIZE_FR * (n + lro_const_total) + SIZE_G2 * (2 + M) +
+                       SIZE_G1 * (M - (nPublic + nConst) + 3 + n + 2 * M);
     char buff_pk[buff_pk_size];
 
     mpz_out_raw(fpk, pk->Ne);
@@ -206,7 +208,7 @@ void serialize_pk(proving_key *pk)
         size += mclBnG2_serialize(buff_pk + size, SIZE_G2, &pk->B2[i]);
     }
 
-    for (int i = 0; i < M-(nPublic + nConst); i++)
+    for (int i = 0; i < M - (nPublic + nConst); i++)
     {
         size += mclBnG1_serialize(buff_pk + size, SIZE_G1, &pk->pk1[i]);
     }
@@ -220,9 +222,9 @@ void serialize_pk(proving_key *pk)
     fclose(fpk);
 }
 
-void serialize_vk(verifying_key *vk)
+void serialize_vk(verifying_key* vk)
 {
-    FILE *fvk;
+    FILE* fvk;
     fvk = fopen("data/verifyingkey.params", "w");
 
     int buff_vk_size = SIZE_GT + SIZE_G2 * 2 + SIZE_G1 * (nPublic + nConst) + SIZE_FR * nConst;
@@ -234,7 +236,7 @@ void serialize_vk(verifying_key *vk)
     {
         size += mclBnFr_serialize(buff_vk + size, SIZE_FR, &vk->constants[i]);
     }
-    
+
     size += mclBnGT_serialize(buff_vk + size, SIZE_GT, &vk->alphabetaT);
     size += mclBnG2_serialize(buff_vk + size, SIZE_G2, &vk->gamma2);
     size += mclBnG2_serialize(buff_vk + size, SIZE_G2, &vk->delta2);
@@ -248,21 +250,22 @@ void serialize_vk(verifying_key *vk)
     fclose(fvk);
 }
 
-void store_setup(setup_keys *keys)
+void store_setup(setup_keys* keys)
 {
     struct stat st = {0};
-    if (stat("data", &st) == -1) mkdir("data", 0700);
+    if (stat("data", &st) == -1)
+        mkdir("data", 0700);
 
     serialize_pk(&keys->pk);
     serialize_vk(&keys->vk);
 }
 
-setup_keys read_setup(void *circuit)
+setup_keys read_setup(void* circuit)
 {
     init_setup(circuit);
 
     FILE *fpk, *fvk;
-    
+
     fpk = fopen("data/provingkey.params", "r");
     fvk = fopen("data/verifyingkey.params", "r");
 
@@ -273,9 +276,10 @@ setup_keys read_setup(void *circuit)
 
     int n = mpz_get_ui(keys.pk.Ne);
 
-    int buff_pk_size = SIZE_FR * (n + lro_const_total) + SIZE_G2 * (2 + M) + SIZE_G1 * (M - (nPublic + nConst) + 3 + n + 2 * M);
+    int buff_pk_size = SIZE_FR * (n + lro_const_total) + SIZE_G2 * (2 + M) +
+                       SIZE_G1 * (M - (nPublic + nConst) + 3 + n + 2 * M);
     char buff_pk[buff_pk_size];
-    
+
     keys.pk.wM = (mclBnFr*) malloc((n) * sizeof(mclBnFr));
     keys.vk.vk1 = (mclBnG1*) malloc(((nPublic + nConst)) * sizeof(mclBnG1));
     keys.vk.constants = (mclBnFr*) malloc(((nConst)) * sizeof(mclBnFr));
@@ -284,7 +288,7 @@ setup_keys read_setup(void *circuit)
     keys.pk.xt1_rand = (mclBnG1*) malloc((n) * sizeof(mclBnG1));
     keys.pk.A1 = (mclBnG1*) malloc((M) * sizeof(mclBnG1));
     keys.pk.B1 = (mclBnG1*) malloc((M) * sizeof(mclBnG1));
-    keys.pk.pk1 = (mclBnG1*) malloc((M-(nPublic + nConst)) * sizeof(mclBnG1));
+    keys.pk.pk1 = (mclBnG1*) malloc((M - (nPublic + nConst)) * sizeof(mclBnG1));
     keys.pk.B2 = (mclBnG2*) malloc((M) * sizeof(mclBnG2));
     keys.pk.LRO_constants = (mclBnFr*) malloc((lro_const_total) * sizeof(mclBnFr));
 
@@ -293,7 +297,7 @@ setup_keys read_setup(void *circuit)
     mpz_inp_raw(factor, fpk);
 
     keys.pk.qap_size = mpz_get_si(factor);
-    keys.pk.LRO = (int*) malloc((keys.pk.qap_size) * sizeof(int)); 
+    keys.pk.LRO = (int*) malloc((keys.pk.qap_size) * sizeof(int));
 
     for (int i = 0; i < keys.pk.qap_size; i++)
     {
@@ -313,7 +317,7 @@ setup_keys read_setup(void *circuit)
     {
         size += mclBnFr_deserialize(&keys.pk.wM[i], buff_pk + size, SIZE_FR);
     }
-        
+
     size += mclBnG1_deserialize(&keys.pk.alpha1, buff_pk + size, SIZE_G1);
     size += mclBnG1_deserialize(&keys.pk.beta1, buff_pk + size, SIZE_G1);
     size += mclBnG2_deserialize(&keys.pk.beta2, buff_pk + size, SIZE_G2);
@@ -327,7 +331,7 @@ setup_keys read_setup(void *circuit)
         size += mclBnG2_deserialize(&keys.pk.B2[i], buff_pk + size, SIZE_G2);
     }
 
-    for (int i = 0; i < M-(nPublic + nConst); i++)
+    for (int i = 0; i < M - (nPublic + nConst); i++)
     {
         size += mclBnG1_deserialize(&keys.pk.pk1[i], buff_pk + size, SIZE_G1);
     }
@@ -336,7 +340,7 @@ setup_keys read_setup(void *circuit)
     {
         size += mclBnG1_deserialize(&keys.pk.xt1[i], buff_pk + size, SIZE_G1);
     }
-    
+
     char buff_vk[SIZE_GT + SIZE_G2 * 2 + SIZE_G1 * (nPublic + nConst) + SIZE_FR * nConst];
     size = 0;
 
@@ -358,13 +362,13 @@ setup_keys read_setup(void *circuit)
         size += mclBnG1_deserialize(&keys.vk.vk1[i], buff_vk + size, SIZE_G1);
     }
 
-    fclose(fpk); 
+    fclose(fpk);
     fclose(fvk);
 
     return keys;
 }
 
-proof generate_proof(void *circuit, proving_key *pk)
+proof generate_proof(void* circuit, proving_key* pk)
 {
     init_prover(circuit, pk);
 
@@ -378,12 +382,13 @@ proof generate_proof(void *circuit, proving_key *pk)
 
     int n = mpz_get_ui(pk->Ne);
     wM = (mpz_t*) malloc((n) * sizeof(mpz_t));
-    
+
     proof p;
 
     p.uwProof = (mclBnFr*) malloc((nPublic) * sizeof(mclBnFr));
 
-    if (bench) printf("--- Computing proof...\n");
+    if (bench)
+        printf("--- Computing proof...\n");
     struct timespec begin, end;
     double elapsed;
     clock_gettime(CLOCK_MONOTONIC, &begin);
@@ -395,7 +400,8 @@ proof generate_proof(void *circuit, proving_key *pk)
     elapsed += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
 
     log_success("Proof generated successfully in ", 1);
-    if (bench) printf("%fs\n", elapsed);
+    if (bench)
+        printf("%fs\n", elapsed);
 
     for (int i = 0; i < n; i++)
     {
@@ -410,10 +416,10 @@ proof generate_proof(void *circuit, proving_key *pk)
     return p;
 }
 
-void store_proof(proof *p)
+void store_proof(proof* p)
 {
     char buff[2048];
-    FILE *fproof;
+    FILE* fproof;
     fproof = fopen("data/proof.params", "w");
 
     int size = 0;
@@ -436,7 +442,7 @@ proof read_proof()
     proof p;
 
     char buff[2048];
-    FILE *fproof;
+    FILE* fproof;
     fproof = fopen("data/proof.params", "r");
 
     p.uwProof = (mclBnFr*) malloc((nPublic) * sizeof(mclBnFr));
@@ -459,7 +465,7 @@ proof read_proof()
     return p;
 }
 
-int verify_proof(void *circuit, proof *p, verifying_key *vk)
+int verify_proof(void* circuit, proof* p, verifying_key* vk)
 {
     init_setup(circuit);
 
@@ -475,7 +481,8 @@ int verify_proof(void *circuit, proof *p, verifying_key *vk)
         elapsed = (end.tv_sec - begin.tv_sec);
         elapsed += (end.tv_nsec - begin.tv_nsec) / 1000000000.0;
         log_success("Proof verified in ", 1);
-        if (bench) printf("%fs\n", elapsed);
+        if (bench)
+            printf("%fs\n", elapsed);
     }
     else
     {
diff --git a/src/zpie.h b/src/zpie.h
index 3133fbe..23a967e 100644
--- a/src/zpie.h
+++ b/src/zpie.h
@@ -1,55 +1,79 @@
 #include <mcl/bn_c384_256.h>
 
 #ifdef BN128
-    #define USEDCURVE MCL_BN_SNARK1
-    #define BITS 254
-    #define SIZE_FR 32
-    #define SIZE_G1 32
-    #define SIZE_G2 64
-    #define SIZE_GT 384
-    #define PRIMESTR "21888242871839275222246405745257275088548364400416034343698204186575808495617"
-    #define GROUPGEN 5
-    #define GGEN "1 1 2"
-    #define HGEN "1 10857046999023057135944570762232829481370756359578518086990519993285655852781 11559732032986387107991004021392285783925812861821192530917403151452391805634 8495653923123431417604973247489272438418190587263600148770280649306958101930 4082367875863433681332203403145435568316851327593401208105741076214120093531"
-    #define SEED1 "12240074246416256392170098003078167155411687643283363511613846943233267248740"
-    #define SEED2 "343068200766678522613540249871646276936501879543207507284832640577391066390"
-    #define SEED3 "2638070508314633938838656314678915510188754475627216070946991168461793987539"
+#define USEDCURVE MCL_BN_SNARK1
+#define BITS 254
+#define SIZE_FR 32
+#define SIZE_G1 32
+#define SIZE_G2 64
+#define SIZE_GT 384
+#define PRIMESTR "21888242871839275222246405745257275088548364400416034343698204186575808495617"
+#define GROUPGEN 5
+#define GGEN "1 1 2"
+#define HGEN                                                                                       \
+    "1 10857046999023057135944570762232829481370756359578518086990519993285655852781 "             \
+    "11559732032986387107991004021392285783925812861821192530917403151452391805634 "               \
+    "8495653923123431417604973247489272438418190587263600148770280649306958101930 "                \
+    "4082367875863433681332203403145435568316851327593401208105741076214120093531"
+#define SEED1 "12240074246416256392170098003078167155411687643283363511613846943233267248740"
+#define SEED2 "343068200766678522613540249871646276936501879543207507284832640577391066390"
+#define SEED3 "2638070508314633938838656314678915510188754475627216070946991168461793987539"
 #elif BLS12_381
-    #define USEDCURVE MCL_BLS12_381
-    #define BITS 255
-    #define SIZE_FR 32
-    #define SIZE_G1 48
-    #define SIZE_G2 96
-    #define SIZE_GT 576
-    #define PRIMESTR "52435875175126190479447740508185965837690552500527637822603658699938581184513"
-    #define GROUPGEN 7
-    #define GGEN "1 3685416753713387016781088315183077757961620795782546409894578378688607592378376318836054947676345821548104185464507 1339506544944476473020471379941921221584933875938349620426543736416511423956333506472724655353366534992391756441569"
-    #define HGEN "1 352701069587466618187139116011060144890029952792775240219908644239793785735715026873347600343865175952761926303160 3059144344244213709971259814753781636986470325476647558659373206291635324768958432433509563104347017837885763365758 1985150602287291935568054521177171638300868978215655730859378665066344726373823718423869104263333984641494340347905 927553665492332455747201965776037880757740193453592970025027978793976877002675564980949289727957565575433344219582"
-    #define SEED1 "36927108280682610572751541835651759786319781688803963047055892652598699269454" 
-    #define SEED2 "48642930395851658792769562567117246310440249719334092526800582777656115356016" 
-    #define SEED3 "9337391987890516768459279655811256076141636705119217609748065801581636739148"  
+#define USEDCURVE MCL_BLS12_381
+#define BITS 255
+#define SIZE_FR 32
+#define SIZE_G1 48
+#define SIZE_G2 96
+#define SIZE_GT 576
+#define PRIMESTR "52435875175126190479447740508185965837690552500527637822603658699938581184513"
+#define GROUPGEN 7
+#define GGEN                                                                                       \
+    "1 "                                                                                           \
+    "36854167537133870167810883151830777579616207957825464098945783786886075923783763188360549476" \
+    "76345821548104185464507 "                                                                     \
+    "13395065449444764730204713799419212215849338759383496204265437364165114239563335064727246553" \
+    "53366534992391756441569"
+#define HGEN                                                                                       \
+    "1 "                                                                                           \
+    "35270106958746661818713911601106014489002995279277524021990864423979378573571502687334760034" \
+    "3865175952761926303160 "                                                                      \
+    "30591443442442137099712598147537816369864703254766475586593732062916353247689584324335095631" \
+    "04347017837885763365758 "                                                                     \
+    "19851506022872919355680545211771716383008689782156557308593786650663447263738237184238691042" \
+    "63333984641494340347905 "                                                                     \
+    "92755366549233245574720196577603788075774019345359297002502797879397687700267556498094928972" \
+    "7957565575433344219582"
+#define SEED1 "36927108280682610572751541835651759786319781688803963047055892652598699269454"
+#define SEED2 "48642930395851658792769562567117246310440249719334092526800582777656115356016"
+#define SEED3 "9337391987890516768459279655811256076141636705119217609748065801581636739148"
 #endif
 
-#include <stdio.h>
+#include "CUnit/Basic.h"
+#include "common/sha256.c"
 #include <gmp.h>
-#include <sys/stat.h>
+#include <math.h>
+#include <omp.h>
+#include <stdio.h>
 #include <string.h>
+#include <sys/stat.h>
 #include <time.h>
-#include <omp.h>
-#include <math.h> 
-#include "common/sha256.c" 
-#include "CUnit/Basic.h"
 
 #ifndef IS_MAC_OS
-    #include <sys/sysinfo.h>
+#include <sys/sysinfo.h>
 #endif
 
-int init_suite(void) { return 0; }
-int clean_suite(void) { return 0; }
+int init_suite(void)
+{
+    return 0;
+}
+int clean_suite(void)
+{
+    return 0;
+}
 
 int logN;
 int Nb;
-int Mc; 
+int Mc;
 
 static int M;
 int N;
@@ -57,37 +81,37 @@ int nPublic;
 int nConst;
 int setParams;
 
-mclBnFr *uw;
+mclBnFr* uw;
 
 typedef struct
 {
-    mclBnFr *gammas;
-    mclBnG1 *V;
+    mclBnFr* gammas;
+    mclBnG1* V;
     mclBnG1 G;
     mclBnG1 H;
 } context;
 
 typedef struct
 {
-    mclBnFr *uwProof;
+    mclBnFr* uwProof;
     mclBnG1 piA, piC;
     mclBnG2 piB2;
 } proof;
 
 #include "gro16/gro16.h"
 
-void bulletproof_prove(unsigned char *si[]);
+void bulletproof_prove(unsigned char* si[]);
 int bulletproof_verify();
 void bulletproof_save();
 void bulletproof_read();
 static inline void bulletproof_init(int Nb_set, int Mc_set);
-static inline void bulletproof_get_context(context *ctx);
+static inline void bulletproof_get_context(context* ctx);
 static inline void bulletproof_user_gammas(int val);
-void init_setup(void *circuit);
-setup_keys perform_setup(void *circuit);
-void init_prover(void *circuit, proving_key *pk);
-proof generate_proof(void *circuit, proving_key *pk);
-int verify_proof(void *circuit, proof *p, verifying_key *vk);
+void init_setup(void* circuit);
+setup_keys perform_setup(void* circuit);
+void init_prover(void* circuit, proving_key* pk);
+proof generate_proof(void* circuit, proving_key* pk);
+int verify_proof(void* circuit, proof* p, verifying_key* vk);
 
-#include "zpie.c"
-#include "bulletproofs/bulletproofs.c"
\ No newline at end of file
+#include "bulletproofs/bulletproofs.c"
+#include "zpie.c"
\ No newline at end of file