diff --git a/version3/c/amcl.h b/version3/c/amcl.h
index f72557d..a976e9f 100644
--- a/version3/c/amcl.h
+++ b/version3/c/amcl.h
@@ -57,11 +57,11 @@
 #define D_TYPE 0
 #define M_TYPE 1
 
-#define FP_ZERO 0
-#define FP_UNITY 1
-#define FP_SPARSER 2
-#define FP_SPARSE 3
-#define FP_DENSE 4
+#define AMCL_FP_ZERO 0
+#define AMCL_FP_UNITY 1
+#define AMCL_AMCL_FP_SPARSER 2
+#define AMCL_FP_SPARSE 3
+#define AMCL_FP_DENSE 4
 
 
 /**
diff --git a/version3/c/big.c b/version3/c/big.c
index 664cccf..3af1912 100644
--- a/version3/c/big.c
+++ b/version3/c/big.c
@@ -143,7 +143,7 @@
     int i;
     BIG_XXX c;
     BIG_XXX_copy(c,a);
-	BIG_XXX_norm(c);
+    BIG_XXX_norm(c);
     for (i=MODBYTES_XXX-1; i>=0; i--)
     {
         b[i]=c[0]&0xff;
@@ -371,8 +371,8 @@
 void BIG_XXX_or(BIG_XXX c,BIG_XXX a,BIG_XXX b)
 {
     int i;
-	BIG_XXX_norm(a);
-	BIG_XXX_norm(b);
+    BIG_XXX_norm(a);
+    BIG_XXX_norm(b);
     for (i=0; i<NLEN_XXX; i++)
         c[i]=a[i]|b[i];
 #ifdef DEBUG_NORM
@@ -876,28 +876,28 @@
 /* Fast combined shift, subtract and norm. Return sign of result */
 int BIG_XXX_ssn(BIG_XXX r,BIG_XXX a,BIG_XXX m)
 {
-	int i,n=NLEN_XXX-1;
-	chunk carry;
-	m[0]=(m[0]>>1)|((m[1]<<(BASEBITS_XXX-1))&BMASK_XXX);
-	r[0]=a[0]-m[0];
+    int i,n=NLEN_XXX-1;
+    chunk carry;
+    m[0]=(m[0]>>1)|((m[1]<<(BASEBITS_XXX-1))&BMASK_XXX);
+    r[0]=a[0]-m[0];
     carry=r[0]>>BASEBITS_XXX;
     r[0]&=BMASK_XXX;
-    
-	for (i=1;i<n;i++)
-	{
-		m[i]=(m[i]>>1)|((m[i+1]<<(BASEBITS_XXX-1))&BMASK_XXX);
-		r[i]=a[i]-m[i]+carry;
-		carry=r[i]>>BASEBITS_XXX;
-		r[i]&=BMASK_XXX;
-	}
-	
-	m[n]>>=1;
-	r[n]=a[n]-m[n]+carry;
+
+    for (i=1; i<n; i++)
+    {
+        m[i]=(m[i]>>1)|((m[i+1]<<(BASEBITS_XXX-1))&BMASK_XXX);
+        r[i]=a[i]-m[i]+carry;
+        carry=r[i]>>BASEBITS_XXX;
+        r[i]&=BMASK_XXX;
+    }
+
+    m[n]>>=1;
+    r[n]=a[n]-m[n]+carry;
 #ifdef DEBUG_NORM
     r[MPV_XXX]=1;
     r[MNV_XXX]=0;
 #endif
-	return ((r[n]>>(CHUNK-1))&1);
+    return ((r[n]>>(CHUNK-1))&1);
 }
 
 /* Faster shift right of a by k bits. Return shifted out part */
@@ -1040,9 +1040,9 @@
 int BIG_XXX_nbits(BIG_XXX a)
 {
     int bts,k=NLEN_XXX-1;
-	BIG_XXX t;
+    BIG_XXX t;
     chunk c;
-	BIG_XXX_copy(t,a);
+    BIG_XXX_copy(t,a);
     BIG_XXX_norm(t);
     while (k>=0 && t[k]==0) k--;
     if (k<0) return 0;
@@ -1060,9 +1060,9 @@
 int BIG_XXX_dnbits(DBIG_XXX a)
 {
     int bts,k=DNLEN_XXX-1;
-	DBIG_XXX t;
+    DBIG_XXX t;
     chunk c;
-	BIG_XXX_dcopy(t,a);
+    BIG_XXX_dcopy(t,a);
     BIG_XXX_dnorm(t);
     while (k>=0 && t[k]==0) k--;
     if (k<0) return 0;
@@ -1083,8 +1083,8 @@
 {
     int k=0;
     BIG_XXX r; /**/
-	BIG_XXX c;
-	BIG_XXX_copy(c,c1);
+    BIG_XXX c;
+    BIG_XXX_copy(c,c1);
 
     BIG_XXX_norm(b);
     if (BIG_XXX_comp(b,c)<0)
@@ -1300,9 +1300,9 @@
 void BIG_XXX_modmul(BIG_XXX r,BIG_XXX a1,BIG_XXX b1,BIG_XXX m)
 {
     DBIG_XXX d;
-	BIG_XXX a,b;
-	BIG_XXX_copy(a,a1);
-	BIG_XXX_copy(b,b1);
+    BIG_XXX a,b;
+    BIG_XXX_copy(a,a1);
+    BIG_XXX_copy(b,b1);
     BIG_XXX_mod(a,m);
     BIG_XXX_mod(b,m);
 
@@ -1315,8 +1315,8 @@
 void BIG_XXX_modsqr(BIG_XXX r,BIG_XXX a1,BIG_XXX m)
 {
     DBIG_XXX d;
-	BIG_XXX a;
-	BIG_XXX_copy(a,a1);
+    BIG_XXX a;
+    BIG_XXX_copy(a,a1);
     BIG_XXX_mod(a,m);
     BIG_XXX_sqr(d,a);
     BIG_XXX_dmod(r,d,m);
@@ -1326,8 +1326,8 @@
 /* SU= 16 */
 void BIG_XXX_modneg(BIG_XXX r,BIG_XXX a1,BIG_XXX m)
 {
-	BIG_XXX a;
-	BIG_XXX_copy(a,a1);
+    BIG_XXX a;
+    BIG_XXX_copy(a,a1);
     BIG_XXX_mod(a,m);
     BIG_XXX_sub(r,m,a);
 }
@@ -1338,9 +1338,9 @@
 {
     DBIG_XXX d;
     BIG_XXX z;
-	BIG_XXX a,b;
-	BIG_XXX_copy(a,a1);
-	BIG_XXX_copy(b,b1);
+    BIG_XXX a,b;
+    BIG_XXX_copy(a,a1);
+    BIG_XXX_copy(b,b1);
 
     BIG_XXX_mod(a,m);
     BIG_XXX_invmodp(z,b,m);
diff --git a/version3/c/big.h b/version3/c/big.h
index 7874450..7e89b36 100644
--- a/version3/c/big.h
+++ b/version3/c/big.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file big.h
+ * @file big_XXX.h
  * @author Mike Scott
  * @brief BIG Header File
  *
diff --git a/version3/c/config_big.h b/version3/c/config_big.h
index 76822ed..4640b21 100644
--- a/version3/c/config_big.h
+++ b/version3/c/config_big.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file config_big.h
+ * @file config_big_XXX.h
  * @author Mike Scott
  * @brief Config BIG  Header File
  *
diff --git a/version3/c/config_ff.h b/version3/c/config_ff.h
index 173dab7..65595da 100644
--- a/version3/c/config_ff.h
+++ b/version3/c/config_ff.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file config_ff.h
+ * @file config_ff_WWW.h
  * @author Mike Scott
  * @brief COnfig FF Header File
  *
diff --git a/version3/c/ecdh.c b/version3/c/ecdh.c
index 953685d..216c509 100644
--- a/version3/c/ecdh.c
+++ b/version3/c/ecdh.c
@@ -33,11 +33,11 @@
  * otherwise it is generated randomly internally */
 int ECP_ZZZ_KEY_PAIR_GENERATE(csprng *RNG,octet* S,octet *W)
 {
-    BIG_XXX r,gx,gy,s;
+    BIG_XXX r,s;
     ECP_ZZZ G;
     int res=0;
 
-	ECP_ZZZ_generator(&G);
+    ECP_ZZZ_generator(&G);
 
     BIG_XXX_rcopy(r,CURVE_Order_ZZZ);
     if (RNG!=NULL)
@@ -59,7 +59,7 @@
 
     ECP_ZZZ_mul(&G,s);
 
-	ECP_ZZZ_toOctet(W,&G,false);  /* To use point compression on public keys, change to true */
+    ECP_ZZZ_toOctet(W,&G,false);  /* To use point compression on public keys, change to true */
 
     return res;
 }
@@ -67,7 +67,7 @@
 /* Validate public key */
 int ECP_ZZZ_PUBLIC_KEY_VALIDATE(octet *W)
 {
-    BIG_XXX q,r,wx,k;
+    BIG_XXX q,r,k;
     ECP_ZZZ WP;
     int valid,nb;
     int res=0;
@@ -75,11 +75,12 @@
     BIG_XXX_rcopy(q,Modulus_YYY);
     BIG_XXX_rcopy(r,CURVE_Order_ZZZ);
 
-	valid=ECP_ZZZ_fromOctet(&WP,W);
-	if (!valid) res=ECDH_INVALID_PUBLIC_KEY;
+    valid=ECP_ZZZ_fromOctet(&WP,W);
+    if (!valid) res=ECDH_INVALID_PUBLIC_KEY;
 
     if (res==0)
-    { /* Check point is not in wrong group */
+    {
+        /* Check point is not in wrong group */
         nb=BIG_XXX_nbits(q);
         BIG_XXX_one(k);
         BIG_XXX_shl(k,(nb+4)/2);
@@ -109,7 +110,7 @@
 
     BIG_XXX_fromBytes(s,S->val);
 
-	valid=ECP_ZZZ_fromOctet(&W,WD);
+    valid=ECP_ZZZ_fromOctet(&W,WD);
 
     if (!valid) res=ECDH_ERROR;
     if (res==0)
@@ -141,12 +142,12 @@
     char h[128];
     octet H= {0,sizeof(h),h};
 
-    BIG_XXX gx,gy,r,s,f,c,d,u,vx,w;
+    BIG_XXX r,s,f,c,d,u,vx,w;
     ECP_ZZZ G,V;
 
     ehashit(sha,F,-1,NULL,&H,sha);
 
-	ECP_ZZZ_generator(&G);
+    ECP_ZZZ_generator(&G);
 
     BIG_XXX_rcopy(r,CURVE_Order_ZZZ);
 
@@ -156,41 +157,42 @@
     if (H.len>MODBYTES_XXX) hlen=MODBYTES_XXX;
     BIG_XXX_fromBytesLen(f,H.val,hlen);
 
-	if (RNG!=NULL)
-	{
-		do
-		{
+    if (RNG!=NULL)
+    {
+        do
+        {
             BIG_XXX_randomnum(u,r,RNG);
             BIG_XXX_randomnum(w,r,RNG); /* side channel masking */
 
 #ifdef AES_S
-			BIG_XXX_mod2m(u,2*AES_S);
+            BIG_XXX_mod2m(u,2*AES_S);
 #endif
-			ECP_ZZZ_copy(&V,&G);
-			ECP_ZZZ_mul(&V,u);
+            ECP_ZZZ_copy(&V,&G);
+            ECP_ZZZ_mul(&V,u);
 
-			ECP_ZZZ_get(vx,vx,&V);
+            ECP_ZZZ_get(vx,vx,&V);
 
-			BIG_XXX_copy(c,vx);
-			BIG_XXX_mod(c,r);
-			if (BIG_XXX_iszilch(c)) continue;
-			
+            BIG_XXX_copy(c,vx);
+            BIG_XXX_mod(c,r);
+            if (BIG_XXX_iszilch(c)) continue;
+
             BIG_XXX_modmul(u,u,w,r);
 
-			BIG_XXX_invmodp(u,u,r);
-			BIG_XXX_modmul(d,s,c,r);
+            BIG_XXX_invmodp(u,u,r);
+            BIG_XXX_modmul(d,s,c,r);
 
-			BIG_XXX_add(d,f,d);
-			
+            BIG_XXX_add(d,f,d);
+
             BIG_XXX_modmul(d,d,w,r);
 
-			BIG_XXX_modmul(d,u,d,r);
-		} while (BIG_XXX_iszilch(d));
-	}
-	else
-	{
-		BIG_XXX_fromBytes(u,K->val);
-		BIG_XXX_mod(u,r);
+            BIG_XXX_modmul(d,u,d,r);
+        }
+        while (BIG_XXX_iszilch(d));
+    }
+    else
+    {
+        BIG_XXX_fromBytes(u,K->val);
+        BIG_XXX_mod(u,r);
 
 #ifdef AES_S
         BIG_XXX_mod2m(u,2*AES_S);
@@ -203,7 +205,7 @@
         BIG_XXX_copy(c,vx);
         BIG_XXX_mod(c,r);
         if (BIG_XXX_iszilch(c)) return ECDH_ERROR;
- 
+
 
         BIG_XXX_invmodp(u,u,r);
         BIG_XXX_modmul(d,s,c,r);
@@ -228,14 +230,14 @@
     char h[128];
     octet H= {0,sizeof(h),h};
 
-    BIG_XXX r,gx,gy,wx,wy,f,c,d,h2;
+    BIG_XXX r,f,c,d,h2;
     int res=0;
     ECP_ZZZ G,WP;
     int valid;
 
     ehashit(sha,F,-1,NULL,&H,sha);
 
-	ECP_ZZZ_generator(&G);
+    ECP_ZZZ_generator(&G);
 
     BIG_XXX_rcopy(r,CURVE_Order_ZZZ);
 
@@ -261,7 +263,7 @@
         BIG_XXX_modmul(f,f,d,r);
         BIG_XXX_modmul(h2,c,d,r);
 
-		valid=ECP_ZZZ_fromOctet(&WP,W);
+        valid=ECP_ZZZ_fromOctet(&WP,W);
 
         if (!valid) res=ECDH_ERROR;
         else
diff --git a/version3/c/ecdh.h b/version3/c/ecdh.h
index 10a1828..cbeae6a 100644
--- a/version3/c/ecdh.h
+++ b/version3/c/ecdh.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file ecdh.h
+ * @file ecdh_ZZZ.h
  * @author Mike Scott
  * @brief ECDH Header file for implementation of standard EC protocols
  *
diff --git a/version3/c/ecp.c b/version3/c/ecp.c
index 60eddaa..f0ae94e 100644
--- a/version3/c/ecp.c
+++ b/version3/c/ecp.c
@@ -191,7 +191,7 @@
 
     FP_YYY_mul(&t,v,&t);
     FP_YYY_sub(&t,&t,&one);
-	FP_YYY_norm(&t);
+    FP_YYY_norm(&t);
     if (CURVE_A_ZZZ==1) FP_YYY_sub(v,v,&one);
 
     if (CURVE_A_ZZZ==-1)
@@ -200,10 +200,10 @@
         FP_YYY_norm(v);
         FP_YYY_neg(v,v);
     }
-	FP_YYY_norm(v);
-	FP_YYY_inv(&t,&t);
-	FP_YYY_mul(v,v,&t);
-	FP_YYY_reduce(v);
+    FP_YYY_norm(v);
+    FP_YYY_inv(&t,&t);
+    FP_YYY_mul(v,v,&t);
+    FP_YYY_reduce(v);
 #endif
 
 #if CURVETYPE_ZZZ==MONTGOMERY
@@ -239,7 +239,7 @@
         ECP_ZZZ_inf(P);
         return 0;
     }
- 
+
     FP_YYY_nres(&(P->x),x);
     FP_YYY_one(&(P->z));
     return 1;
@@ -248,11 +248,11 @@
 /* Extract x coordinate as BIG */
 int ECP_ZZZ_get(BIG_XXX x,ECP_ZZZ *P)
 {
-	ECP_ZZZ W;
-	ECP_ZZZ_copy(&W,P);
-	ECP_ZZZ_affine(&W);
+    ECP_ZZZ W;
+    ECP_ZZZ_copy(&W,P);
+    ECP_ZZZ_affine(&W);
     if (ECP_ZZZ_isinf(&W)) return -1;
-    FP_YYY_redc(x,&(Wx));
+    FP_YYY_redc(x,&(W));
     return 0;
 }
 
@@ -262,10 +262,10 @@
 /* SU=16 */
 int ECP_ZZZ_get(BIG_XXX x,BIG_XXX y,ECP_ZZZ *P)
 {
-	ECP_ZZZ W;
+    ECP_ZZZ W;
     int s;
-	ECP_ZZZ_copy(&W,P);
-	ECP_ZZZ_affine(&W);
+    ECP_ZZZ_copy(&W,P);
+    ECP_ZZZ_affine(&W);
 
     if (ECP_ZZZ_isinf(&W)) return -1;
 
@@ -336,26 +336,27 @@
 #endif
 
 void ECP_ZZZ_cfp(ECP_ZZZ *P)
-{ /* multiply point by curves cofactor */
-	BIG_XXX c;
-	int cf=CURVE_Cof_I_ZZZ;
-	if (cf==1) return;
-	if (cf==4)
-	{
-		ECP_ZZZ_dbl(P);
-		ECP_ZZZ_dbl(P);
-		return;
-	}
-	if (cf==8)
-	{
-		ECP_ZZZ_dbl(P);
-		ECP_ZZZ_dbl(P);
-		ECP_ZZZ_dbl(P);
-		return;
-	}
-	BIG_XXX_rcopy(c,CURVE_Cof_ZZZ);
-	ECP_ZZZ_mul(P,c);
-	return;
+{
+    /* multiply point by curves cofactor */
+    BIG_XXX c;
+    int cf=CURVE_Cof_I_ZZZ;
+    if (cf==1) return;
+    if (cf==4)
+    {
+        ECP_ZZZ_dbl(P);
+        ECP_ZZZ_dbl(P);
+        return;
+    }
+    if (cf==8)
+    {
+        ECP_ZZZ_dbl(P);
+        ECP_ZZZ_dbl(P);
+        ECP_ZZZ_dbl(P);
+        return;
+    }
+    BIG_XXX_rcopy(c,CURVE_Cof_ZZZ);
+    ECP_ZZZ_mul(P,c);
+    return;
 }
 
 /* map BIG to point on curve of correct order */
@@ -364,25 +365,26 @@
 void ECP_ZZZ_mapit(ECP_ZZZ *P,octet *W)
 {
     BIG_XXX q,x;
-	BIG_XXX_fromBytes(x,W->val);
+    BIG_XXX_fromBytes(x,W->val);
     BIG_XXX_rcopy(q,Modulus_YYY);
     BIG_XXX_mod(x,q);
 
-	for (;;)
-	{
-		for (;;)
-		{
+    for (;;)
+    {
+        for (;;)
+        {
 #if CURVETYPE_ZZZ!=MONTGOMERY
-			ECP_ZZZ_setx(P,x,0);
+            ECP_ZZZ_setx(P,x,0);
 #else
-			ECP_ZZZ_set(P,x);
+            ECP_ZZZ_set(P,x);
 #endif
-			BIG_XXX_inc(x,1); BIG_XXX_norm(x);
-			if (!ECP_ZZZ_isinf(P)) break;
-		}
-		ECP_ZZZ_cfp(P);
-		if (!ECP_ZZZ_isinf(P)) break;
-	}
+            BIG_XXX_inc(x,1);
+            BIG_XXX_norm(x);
+            if (!ECP_ZZZ_isinf(P)) break;
+        }
+        ECP_ZZZ_cfp(P);
+        if (!ECP_ZZZ_isinf(P)) break;
+    }
 }
 
 /* Convert P to Affine, from (x,y,z) to (x,y) */
@@ -390,12 +392,11 @@
 void ECP_ZZZ_affine(ECP_ZZZ *P)
 {
     FP_YYY one,iz;
-    BIG_XXX b;
     if (ECP_ZZZ_isinf(P)) return;
     FP_YYY_one(&one);
     if (FP_YYY_equals(&(P->z),&one)) return;
 
-	FP_YYY_inv(&iz,&(P->z));
+    FP_YYY_inv(&iz,&(P->z));
     FP_YYY_mul(&(P->x),&(P->x),&iz);
 
 #if CURVETYPE_ZZZ==EDWARDS || CURVETYPE_ZZZ==WEIERSTRASS
@@ -514,20 +515,20 @@
 #else
     BIG_XXX x,y;
     ECP_ZZZ_get(x,y,P);
-	if (compress)
-	{
-		W->val[0]=0x02;
-		if (BIG_XXX_parity(y)==1) W->val[0]=0x03;
-		W->len=MODBYTES_XXX+1;
-		BIG_XXX_toBytes(&(W->val[1]),x);
-	}
-	else
-	{
-		W->val[0]=4;
-		W->len=2*MODBYTES_XXX+1;
-		BIG_XXX_toBytes(&(W->val[1]),x);
-		BIG_XXX_toBytes(&(W->val[MODBYTES_XXX+1]),y);
-	}
+    if (compress)
+    {
+        W->val[0]=0x02;
+        if (BIG_XXX_parity(y)==1) W->val[0]=0x03;
+        W->len=MODBYTES_XXX+1;
+        BIG_XXX_toBytes(&(W->val[1]),x);
+    }
+    else
+    {
+        W->val[0]=4;
+        W->len=2*MODBYTES_XXX+1;
+        BIG_XXX_toBytes(&(W->val[1]),x);
+        BIG_XXX_toBytes(&(W->val[MODBYTES_XXX+1]),y);
+    }
 #endif
 }
 
@@ -542,17 +543,17 @@
     return 0;
 #else
     BIG_XXX x,y;
-	int typ=W->val[0];
-	BIG_XXX_fromBytes(x,&(W->val[1]));
-	if (typ==0x04)
-	{
-		BIG_XXX_fromBytes(y,&(W->val[MODBYTES_XXX+1]));
-		if (ECP_ZZZ_set(P,x,y)) return 1;
-	}
-	if (typ==0x02 || typ==0x03)
-	{
-		if (ECP_ZZZ_setx(P,x,typ&1)) return 1;
-	}
+    int typ=W->val[0];
+    BIG_XXX_fromBytes(x,&(W->val[1]));
+    if (typ==0x04)
+    {
+        BIG_XXX_fromBytes(y,&(W->val[MODBYTES_XXX+1]));
+        if (ECP_ZZZ_set(P,x,y)) return 1;
+    }
+    if (typ==0x02 || typ==0x03)
+    {
+        if (ECP_ZZZ_setx(P,x,typ&1)) return 1;
+    }
     return 0;
 #endif
 }
@@ -591,7 +592,7 @@
         FP_YYY_mul(&y3,&y3,&t0);				//y3.mul(t0);
         FP_YYY_add(&y3,&y3,&x3);				//y3.add(x3);
         FP_YYY_mul(&t1,&(P->x),&(P->y));			//t1.mul(y);
-       
+
         FP_YYY_norm(&t0);					//x.norm();
         FP_YYY_mul(&(P->x),&t0,&t1);		//x.mul(t1);
         FP_YYY_add(&(P->x),&(P->x),&(P->x));	//x.add(x);
@@ -780,7 +781,7 @@
         FP_YYY_mul(&t2,&(P->z),&(Q->z));		//t2.mul(Q.z);
         FP_YYY_add(&t3,&(P->x),&(P->y));		//t3.add(y);
         FP_YYY_norm(&t3);					//t3.norm();
- 
+
         FP_YYY_add(&t4,&(Q->x),&(Q->y));		//t4.add(Q.y);
         FP_YYY_norm(&t4);					//t4.norm();
         FP_YYY_mul(&t3,&t3,&t4);			//t3.mul(t4);
@@ -847,7 +848,7 @@
         FP_YYY_add(&t4,&(Q->x),&(Q->y));		//t4.add(Q.y);
         FP_YYY_norm(&t4);					//t4.norm();//5
         FP_YYY_mul(&t3,&t3,&t4);			//t3.mul(t4);//6
-    
+
         FP_YYY_add(&t4,&t0,&t1);			//t4.add(t1); //t4.norm(); //7
         FP_YYY_sub(&t3,&t3,&t4);			//t3.sub(t4);
         FP_YYY_norm(&t3);					//t3.norm(); //8
@@ -914,7 +915,7 @@
         FP_YYY_mul(&x3,&x3,&t3);			//x3.mul(t3);//39
         FP_YYY_sub(&(P->x),&x3,&t1);			//x3.sub(t1);//40
         FP_YYY_mul(&z3,&z3,&t4);			//z3.mul(t4);//41
- 
+
         FP_YYY_mul(&t1,&t3,&t0);			//t1.mul(t0);//42
         FP_YYY_add(&(P->z),&z3,&t1);			//z3.add(t1);
         FP_YYY_norm(&(P->x));				//x.norm();
@@ -981,9 +982,9 @@
 /* SU=16 */
 void  ECP_ZZZ_sub(ECP_ZZZ *P,ECP_ZZZ *Q)
 {
-	ECP_ZZZ NQ;
-	ECP_ZZZ_copy(&NQ,Q);
-	ECP_ZZZ_neg(&NQ);
+    ECP_ZZZ NQ;
+    ECP_ZZZ_copy(&NQ,Q);
+    ECP_ZZZ_neg(&NQ);
     ECP_ZZZ_add(P,&NQ);
 }
 
@@ -1219,13 +1220,13 @@
 
 void ECP_ZZZ_generator(ECP_ZZZ *G)
 {
-	BIG_XXX x,y;
-	BIG_XXX_rcopy(x,CURVE_Gx_ZZZ);
+    BIG_XXX x,y;
+    BIG_XXX_rcopy(x,CURVE_Gx_ZZZ);
 #if CURVETYPE_ZZZ!=MONTGOMERY
-	BIG_XXX_rcopy(y,CURVE_Gy_ZZZ);
+    BIG_XXX_rcopy(y,CURVE_Gy_ZZZ);
     ECP_ZZZ_set(G,x,y);
 #else
-	ECP_ZZZ_set(G,x);
+    ECP_ZZZ_set(G,x);
 #endif
 }
 
diff --git a/version3/c/ecp.h b/version3/c/ecp.h
index 01dac7c..f07230b 100644
--- a/version3/c/ecp.h
+++ b/version3/c/ecp.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file ecp.h
+ * @file ecp_ZZZ.h
  * @author Mike Scott
  * @brief ECP Header File
  *
diff --git a/version3/c/ecp2.c b/version3/c/ecp2.c
index 5463c37..4a6f937 100644
--- a/version3/c/ecp2.c
+++ b/version3/c/ecp2.c
@@ -128,9 +128,9 @@
 /* SU= 16 */
 int ECP2_ZZZ_get(FP2_YYY *x,FP2_YYY *y,ECP2_ZZZ *P)
 {
-	ECP2_ZZZ W;
-	ECP2_ZZZ_copy(&W,P);
-	ECP2_ZZZ_affine(&W);
+    ECP2_ZZZ W;
+    ECP2_ZZZ_copy(&W,P);
+    ECP2_ZZZ_affine(&W);
     if (ECP2_ZZZ_isinf(&W)) return -1;
     FP2_YYY_copy(y,&(W.y));
     FP2_YYY_copy(x,&(W.x));
@@ -259,7 +259,7 @@
 
     if (!FP2_YYY_equals(&y2,&rhs))
     {
-		ECP2_ZZZ_inf(P);
+        ECP2_ZZZ_inf(P);
         return 0;
     }
 
@@ -279,7 +279,7 @@
 
     if (!FP2_YYY_sqrt(&y,&y))
     {
-		ECP2_ZZZ_inf(P);
+        ECP2_ZZZ_inf(P);
         return 0;
     }
 
@@ -444,9 +444,9 @@
 /* SU= 16 */
 void ECP2_ZZZ_sub(ECP2_ZZZ *P,ECP2_ZZZ *Q)
 {
-	ECP2_ZZZ NQ;
-	ECP2_ZZZ_copy(&NQ,Q);
-	ECP2_ZZZ_neg(&NQ);
+    ECP2_ZZZ NQ;
+    ECP2_ZZZ_copy(&NQ,Q);
+    ECP2_ZZZ_neg(&NQ);
     ECP2_ZZZ_add(P,&NQ);
 }
 
@@ -534,15 +534,15 @@
 
 // Bos & Costello https://eprint.iacr.org/2013/458.pdf
 // Faz-Hernandez & Longa & Sanchez  https://eprint.iacr.org/2013/158.pdf
-// Side channel attack secure 
+// Side channel attack secure
 
 void ECP2_ZZZ_mul4(ECP2_ZZZ *P,ECP2_ZZZ Q[4],BIG_XXX u[4])
 {
     int i,j,k,nb,pb,bt;
-	ECP2_ZZZ T[8],W;
+    ECP2_ZZZ T[8],W;
     BIG_XXX t[4],mt;
-	sign8 w[NLEN_XXX*BASEBITS_XXX+1];
-	sign8 s[NLEN_XXX*BASEBITS_XXX+1];
+    sign8 w[NLEN_XXX*BASEBITS_XXX+1];
+    sign8 s[NLEN_XXX*BASEBITS_XXX+1];
 
     for (i=0; i<4; i++)
     {
@@ -552,24 +552,24 @@
 // Precomputed table
     ECP2_ZZZ_copy(&T[0],&Q[0]); // Q[0]
     ECP2_ZZZ_copy(&T[1],&T[0]);
-	ECP2_ZZZ_add(&T[1],&Q[1]);	// Q[0]+Q[1]
+    ECP2_ZZZ_add(&T[1],&Q[1]);	// Q[0]+Q[1]
     ECP2_ZZZ_copy(&T[2],&T[0]);
-	ECP2_ZZZ_add(&T[2],&Q[2]);	// Q[0]+Q[2]
-	ECP2_ZZZ_copy(&T[3],&T[1]);
-	ECP2_ZZZ_add(&T[3],&Q[2]);	// Q[0]+Q[1]+Q[2]
-	ECP2_ZZZ_copy(&T[4],&T[0]);
-	ECP2_ZZZ_add(&T[4],&Q[3]);  // Q[0]+Q[3]
-	ECP2_ZZZ_copy(&T[5],&T[1]);
-	ECP2_ZZZ_add(&T[5],&Q[3]);	// Q[0]+Q[1]+Q[3]
-	ECP2_ZZZ_copy(&T[6],&T[2]);
-	ECP2_ZZZ_add(&T[6],&Q[3]);	// Q[0]+Q[2]+Q[3]
-	ECP2_ZZZ_copy(&T[7],&T[3]);
-	ECP2_ZZZ_add(&T[7],&Q[3]);	// Q[0]+Q[1]+Q[2]+Q[3]
+    ECP2_ZZZ_add(&T[2],&Q[2]);	// Q[0]+Q[2]
+    ECP2_ZZZ_copy(&T[3],&T[1]);
+    ECP2_ZZZ_add(&T[3],&Q[2]);	// Q[0]+Q[1]+Q[2]
+    ECP2_ZZZ_copy(&T[4],&T[0]);
+    ECP2_ZZZ_add(&T[4],&Q[3]);  // Q[0]+Q[3]
+    ECP2_ZZZ_copy(&T[5],&T[1]);
+    ECP2_ZZZ_add(&T[5],&Q[3]);	// Q[0]+Q[1]+Q[3]
+    ECP2_ZZZ_copy(&T[6],&T[2]);
+    ECP2_ZZZ_add(&T[6],&Q[3]);	// Q[0]+Q[2]+Q[3]
+    ECP2_ZZZ_copy(&T[7],&T[3]);
+    ECP2_ZZZ_add(&T[7],&Q[3]);	// Q[0]+Q[1]+Q[2]+Q[3]
 
 // Make it odd
-	pb=1-BIG_XXX_parity(t[0]);
-	BIG_XXX_inc(t[0],pb);
-	BIG_XXX_norm(t[0]);
+    pb=1-BIG_XXX_parity(t[0]);
+    BIG_XXX_inc(t[0],pb);
+    BIG_XXX_norm(t[0]);
 
 // Number of bits
     BIG_XXX_zero(mt);
@@ -579,33 +579,33 @@
     }
     nb=1+BIG_XXX_nbits(mt);
 
-// Sign pivot 
-	s[nb-1]=1;
-	for (i=0;i<nb-1;i++)
-	{
+// Sign pivot
+    s[nb-1]=1;
+    for (i=0; i<nb-1; i++)
+    {
         BIG_XXX_fshr(t[0],1);
-		s[i]=2*BIG_XXX_parity(t[0])-1;
-	}
+        s[i]=2*BIG_XXX_parity(t[0])-1;
+    }
 
 // Recoded exponent
     for (i=0; i<nb; i++)
     {
-		w[i]=0;
-		k=1;
-		for (j=1; j<4; j++)
-		{
-			bt=s[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w[i]=0;
+        k=1;
+        for (j=1; j<4; j++)
+        {
+            bt=s[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w[i]+=bt*k;
+            k*=2;
         }
-    }		
+    }
 
 // Main loop
-	ECP2_ZZZ_select(P,T,2*w[nb-1]+1);
+    ECP2_ZZZ_select(P,T,2*w[nb-1]+1);
     for (i=nb-2; i>=0; i--)
     {
         ECP2_ZZZ_select(&W,T,2*w[i]+s[i]);
@@ -614,9 +614,9 @@
     }
 
 // apply correction
-	ECP2_ZZZ_copy(&W,P);   
-	ECP2_ZZZ_sub(&W,&Q[0]);
-	ECP2_ZZZ_cmove(P,&W,pb);
+    ECP2_ZZZ_copy(&W,P);
+    ECP2_ZZZ_sub(&W,&Q[0]);
+    ECP2_ZZZ_cmove(P,&W,pb);
 
     ECP2_ZZZ_affine(P);
 }
@@ -713,12 +713,12 @@
 
 void ECP2_ZZZ_generator(ECP2_ZZZ *G)
 {
-	FP2_YYY wx,wy;
+    FP2_YYY wx,wy;
 
-    FP_YYY_rcopy(&(wx.a),CURVE_Pxa_ZZZ); 
-    FP_YYY_rcopy(&(wx.b),CURVE_Pxb_ZZZ); 
-    FP_YYY_rcopy(&(wy.a),CURVE_Pya_ZZZ); 
-    FP_YYY_rcopy(&(wy.b),CURVE_Pyb_ZZZ);     
+    FP_YYY_rcopy(&(wx.a),CURVE_Pxa_ZZZ);
+    FP_YYY_rcopy(&(wx.b),CURVE_Pxb_ZZZ);
+    FP_YYY_rcopy(&(wy.a),CURVE_Pya_ZZZ);
+    FP_YYY_rcopy(&(wy.b),CURVE_Pyb_ZZZ);
 
-	ECP2_ZZZ_set(G,&wx,&wy);
+    ECP2_ZZZ_set(G,&wx,&wy);
 }
diff --git a/version3/c/ecp2.h b/version3/c/ecp2.h
index 32c0420..046953a 100644
--- a/version3/c/ecp2.h
+++ b/version3/c/ecp2.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file ecp2.h
+ * @file ecp2_ZZZ.h
  * @author Mike Scott
  * @brief ECP2 Header File
  *
diff --git a/version3/c/ecp4.c b/version3/c/ecp4.c
index e8148c4..3f95f7a 100644
--- a/version3/c/ecp4.c
+++ b/version3/c/ecp4.c
@@ -23,7 +23,7 @@
 
 int ECP4_ZZZ_isinf(ECP4_ZZZ *P)
 {
-	return (FP4_YYY_iszilch(&(P->x)) & FP4_YYY_iszilch(&(P->z)));
+    return (FP4_YYY_iszilch(&(P->x)) & FP4_YYY_iszilch(&(P->z)));
 }
 
 /* Set P=Q */
@@ -31,7 +31,7 @@
 {
     FP4_YYY_copy(&(P->x),&(Q->x));
     FP4_YYY_copy(&(P->y),&(Q->y));
-	FP4_YYY_copy(&(P->z),&(Q->z));
+    FP4_YYY_copy(&(P->z),&(Q->z));
 }
 
 /* set P to Infinity */
@@ -125,9 +125,9 @@
 /* extract x, y from point P */
 int ECP4_ZZZ_get(FP4_YYY *x,FP4_YYY *y,ECP4_ZZZ *P)
 {
-	ECP4_ZZZ W;
-	ECP4_ZZZ_copy(&W,P);
-	ECP4_ZZZ_affine(&W);
+    ECP4_ZZZ W;
+    ECP4_ZZZ_copy(&W,P);
+    ECP4_ZZZ_affine(&W);
     if (ECP4_ZZZ_isinf(&W)) return -1;
     FP4_YYY_copy(y,&(W.y));
     FP4_YYY_copy(x,&(W.x));
@@ -154,16 +154,16 @@
 /* Convert Q to octet string */
 void ECP4_ZZZ_toOctet(octet *W,ECP4_ZZZ *Q)
 {
-	BIG_XXX b;
-	FP4_YYY qx,qy;
-	FP2_YYY pa,pb;
+    BIG_XXX b;
+    FP4_YYY qx,qy;
+    FP2_YYY pa,pb;
 
     ECP4_ZZZ_get(&qx,&qy,Q);
 
-	FP2_YYY_copy(&pa,&(qx.a));
-	FP2_YYY_copy(&pb,&(qx.b));
+    FP2_YYY_copy(&pa,&(qx.a));
+    FP2_YYY_copy(&pb,&(qx.b));
 
-	FP_YYY_redc(b,&(pa.a));
+    FP_YYY_redc(b,&(pa.a));
     BIG_XXX_toBytes(&(W->val[0]),b);
     FP_YYY_redc(b,&(pa.b));
     BIG_XXX_toBytes(&(W->val[MODBYTES_XXX]),b);
@@ -172,10 +172,10 @@
     FP_YYY_redc(b,&(pb.b));
     BIG_XXX_toBytes(&(W->val[3*MODBYTES_XXX]),b);
 
-	FP2_YYY_copy(&pa,&(qy.a));
-	FP2_YYY_copy(&pb,&(qy.b));
-	
-	FP_YYY_redc(b,&(pa.a));
+    FP2_YYY_copy(&pa,&(qy.a));
+    FP2_YYY_copy(&pb,&(qy.b));
+
+    FP_YYY_redc(b,&(pa.a));
     BIG_XXX_toBytes(&(W->val[4*MODBYTES_XXX]),b);
     FP_YYY_redc(b,&(pa.b));
     BIG_XXX_toBytes(&(W->val[5*MODBYTES_XXX]),b);
@@ -190,12 +190,12 @@
 /* restore Q from octet string */
 int ECP4_ZZZ_fromOctet(ECP4_ZZZ *Q,octet *W)
 {
-	BIG_XXX b;
+    BIG_XXX b;
     FP4_YYY qx,qy;
-	FP2_YYY pa,pb;
+    FP2_YYY pa,pb;
 
     BIG_XXX_fromBytes(b,&(W->val[0]));
-	FP_YYY_nres(&(pa.a),b);
+    FP_YYY_nres(&(pa.a),b);
     BIG_XXX_fromBytes(b,&(W->val[MODBYTES_XXX]));
     FP_YYY_nres(&(pa.b),b);
     BIG_XXX_fromBytes(b,&(W->val[2*MODBYTES_XXX]));
@@ -203,11 +203,11 @@
     BIG_XXX_fromBytes(b,&(W->val[3*MODBYTES_XXX]));
     FP_YYY_nres(&(pb.b),b);
 
-	FP2_YYY_copy(&(qx.a),&pa);
-	FP2_YYY_copy(&(qx.b),&pb);
+    FP2_YYY_copy(&(qx.a),&pa);
+    FP2_YYY_copy(&(qx.b),&pb);
 
     BIG_XXX_fromBytes(b,&(W->val[4*MODBYTES_XXX]));
-	FP_YYY_nres(&(pa.a),b);
+    FP_YYY_nres(&(pa.a),b);
     BIG_XXX_fromBytes(b,&(W->val[5*MODBYTES_XXX]));
     FP_YYY_nres(&(pa.b),b);
     BIG_XXX_fromBytes(b,&(W->val[6*MODBYTES_XXX]));
@@ -215,8 +215,8 @@
     BIG_XXX_fromBytes(b,&(W->val[7*MODBYTES_XXX]));
     FP_YYY_nres(&(pb.b),b);
 
-	FP2_YYY_copy(&(qy.a),&pa);
-	FP2_YYY_copy(&(qy.b),&pb);
+    FP2_YYY_copy(&(qy.a),&pa);
+    FP2_YYY_copy(&(qy.b),&pb);
 
 
     if (ECP4_ZZZ_set(Q,&qx,&qy)) return 1;
@@ -228,7 +228,7 @@
 {
     /* calculate RHS of elliptic curve equation */
     FP4_YYY t;
-	FP2_YYY t2;
+    FP2_YYY t2;
     BIG_XXX b;
     FP4_YYY_sqr(&t,x);
 
@@ -239,13 +239,13 @@
     BIG_XXX_rcopy(b,CURVE_B_ZZZ);
 
     FP2_YYY_from_BIG(&t2,b);
-	FP4_YYY_from_FP2(&t,&t2);
+    FP4_YYY_from_FP2(&t,&t2);
 
-#if SEXTIC_TWIST_ZZZ == D_TYPE	
+#if SEXTIC_TWIST_ZZZ == D_TYPE
     FP4_YYY_div_i(&t);   /* IMPORTANT - here we use the correct SEXTIC twist of the curve */
 #endif
 
-#if SEXTIC_TWIST_ZZZ == M_TYPE	
+#if SEXTIC_TWIST_ZZZ == M_TYPE
     FP4_YYY_times_i(&t);   /* IMPORTANT - here we use the correct SEXTIC twist of the curve */
 #endif
 
@@ -264,11 +264,11 @@
 
     if (!FP4_YYY_equals(&y2,&rhs))
     {
-		ECP4_ZZZ_inf(P);
+        ECP4_ZZZ_inf(P);
         return 0;
     }
 
- //   P->inf=0;
+//   P->inf=0;
     FP4_YYY_copy(&(P->x),x);
     FP4_YYY_copy(&(P->y),y);
 
@@ -300,7 +300,7 @@
 /* SU= 8 */
 void ECP4_ZZZ_neg(ECP4_ZZZ *P)
 {
-	FP4_YYY_norm(&(P->y));
+    FP4_YYY_norm(&(P->y));
     FP4_YYY_neg(&(P->y),&(P->y));
     FP4_YYY_norm(&(P->y));
 }
@@ -310,55 +310,55 @@
 /* return -1 for Infinity, 0 for addition, 1 for doubling */
 int ECP4_ZZZ_dbl(ECP4_ZZZ *P)
 {
-    FP4_YYY t0,t1,t2,t3,iy,x3,y3;
+    FP4_YYY t0,t1,t2,iy,x3,y3;
 
-	FP4_YYY_copy(&iy,&(P->y));		//FP4_YYY iy=new FP4_YYY(y);
+    FP4_YYY_copy(&iy,&(P->y));		//FP4_YYY iy=new FP4_YYY(y);
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP4_YYY_times_i(&iy);			//iy.mul_ip(); 
+    FP4_YYY_times_i(&iy);			//iy.mul_ip();
 #endif
 
-	FP4_YYY_sqr(&t0,&(P->y));			//t0.sqr();   
+    FP4_YYY_sqr(&t0,&(P->y));			//t0.sqr();
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP4_YYY_times_i(&t0);			//t0.mul_ip(); 
+    FP4_YYY_times_i(&t0);			//t0.mul_ip();
 #endif
 
-	FP4_YYY_mul(&t1,&iy,&(P->z));	//t1.mul(z);
-	FP4_YYY_sqr(&t2,&(P->z));				//t2.sqr();
+    FP4_YYY_mul(&t1,&iy,&(P->z));	//t1.mul(z);
+    FP4_YYY_sqr(&t2,&(P->z));				//t2.sqr();
 
-	FP4_YYY_add(&(P->z),&t0,&t0);	//z.add(t0); 
-	FP4_YYY_norm(&(P->z));				//z.norm(); 
-	FP4_YYY_add(&(P->z),&(P->z),&(P->z));	//z.add(z); 
-	FP4_YYY_add(&(P->z),&(P->z),&(P->z));	//z.add(z); 
-	FP4_YYY_norm(&(P->z));			//z.norm();  
+    FP4_YYY_add(&(P->z),&t0,&t0);	//z.add(t0);
+    FP4_YYY_norm(&(P->z));				//z.norm();
+    FP4_YYY_add(&(P->z),&(P->z),&(P->z));	//z.add(z);
+    FP4_YYY_add(&(P->z),&(P->z),&(P->z));	//z.add(z);
+    FP4_YYY_norm(&(P->z));			//z.norm();
 
-	FP4_YYY_imul(&t2,&t2,3*CURVE_B_I_ZZZ);	//t2.imul(3*ROM.CURVE_B_I); 
+    FP4_YYY_imul(&t2,&t2,3*CURVE_B_I_ZZZ);	//t2.imul(3*ROM.CURVE_B_I);
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-	FP4_YYY_times_i(&t2);
+    FP4_YYY_times_i(&t2);
 #endif
 
-	FP4_YYY_mul(&x3,&t2,&(P->z));	//x3.mul(z); 
+    FP4_YYY_mul(&x3,&t2,&(P->z));	//x3.mul(z);
 
-	FP4_YYY_add(&y3,&t0,&t2);		//y3.add(t2); 
-	FP4_YYY_norm(&y3);				//y3.norm();
-	FP4_YYY_mul(&(P->z),&(P->z),&t1);	//z.mul(t1);
+    FP4_YYY_add(&y3,&t0,&t2);		//y3.add(t2);
+    FP4_YYY_norm(&y3);				//y3.norm();
+    FP4_YYY_mul(&(P->z),&(P->z),&t1);	//z.mul(t1);
 
-	FP4_YYY_add(&t1,&t2,&t2);		//t1.add(t2); 
-	FP4_YYY_add(&t2,&t2,&t1);		//t2.add(t1); 
-	FP4_YYY_norm(&t2);				//t2.norm();  
-	FP4_YYY_sub(&t0,&t0,&t2);		//t0.sub(t2); 
-	FP4_YYY_norm(&t0);				//t0.norm();                           //y^2-9bz^2
-	FP4_YYY_mul(&y3,&y3,&t0);		//y3.mul(t0); 
-	FP4_YYY_add(&(P->y),&y3,&x3);		//y3.add(x3);                          //(y^2+3z*2)(y^2-9z^2)+3b.z^2.8y^2
+    FP4_YYY_add(&t1,&t2,&t2);		//t1.add(t2);
+    FP4_YYY_add(&t2,&t2,&t1);		//t2.add(t1);
+    FP4_YYY_norm(&t2);				//t2.norm();
+    FP4_YYY_sub(&t0,&t0,&t2);		//t0.sub(t2);
+    FP4_YYY_norm(&t0);				//t0.norm();                           //y^2-9bz^2
+    FP4_YYY_mul(&y3,&y3,&t0);		//y3.mul(t0);
+    FP4_YYY_add(&(P->y),&y3,&x3);		//y3.add(x3);                          //(y^2+3z*2)(y^2-9z^2)+3b.z^2.8y^2
 
-	FP4_YYY_mul(&t1,&(P->x),&iy);		//t1.mul(iy);						//
+    FP4_YYY_mul(&t1,&(P->x),&iy);		//t1.mul(iy);						//
 
-	FP4_YYY_norm(&t0);				//x.norm(); 
-	FP4_YYY_mul(&(P->x),&t0,&t1);	//x.mul(t1); 
-	FP4_YYY_add(&(P->x),&(P->x),&(P->x));	//x.add(x);       //(y^2-9bz^2)xy2
+    FP4_YYY_norm(&t0);				//x.norm();
+    FP4_YYY_mul(&(P->x),&t0,&t1);	//x.mul(t1);
+    FP4_YYY_add(&(P->x),&(P->x),&(P->x));	//x.add(x);       //(y^2-9bz^2)xy2
 
-	FP4_YYY_norm(&(P->x));			//x.norm(); 
+    FP4_YYY_norm(&(P->x));			//x.norm();
 
-	FP4_YYY_norm(&(P->y));			//y.norm();
+    FP4_YYY_norm(&(P->y));			//y.norm();
 
     return 1;
 }
@@ -368,88 +368,88 @@
 int ECP4_ZZZ_add(ECP4_ZZZ *P,ECP4_ZZZ *Q)
 {
     FP4_YYY t0,t1,t2,t3,t4,x3,y3,z3;
-	int b3=3*CURVE_B_I_ZZZ;
+    int b3=3*CURVE_B_I_ZZZ;
 
-	FP4_YYY_mul(&t0,&(P->x),&(Q->x));	//t0.mul(Q.x);         // x.Q.x
-	FP4_YYY_mul(&t1,&(P->y),&(Q->y));	//t1.mul(Q.y);		 // y.Q.y
+    FP4_YYY_mul(&t0,&(P->x),&(Q->x));	//t0.mul(Q.x);         // x.Q.x
+    FP4_YYY_mul(&t1,&(P->y),&(Q->y));	//t1.mul(Q.y);		 // y.Q.y
 
-	FP4_YYY_mul(&t2,&(P->z),&(Q->z));	//t2.mul(Q.z);
-	FP4_YYY_add(&t3,&(P->x),&(P->y));	//t3.add(y); 
-	FP4_YYY_norm(&t3);				//t3.norm();          //t3=X1+Y1         
-	FP4_YYY_add(&t4,&(Q->x),&(Q->y));	//t4.add(Q.y); 
-	FP4_YYY_norm(&t4);				//t4.norm();			//t4=X2+Y2
-	FP4_YYY_mul(&t3,&t3,&t4);		//t3.mul(t4);						//t3=(X1+Y1)(X2+Y2)
-	FP4_YYY_add(&t4,&t0,&t1);		//t4.add(t1);		//t4=X1.X2+Y1.Y2
+    FP4_YYY_mul(&t2,&(P->z),&(Q->z));	//t2.mul(Q.z);
+    FP4_YYY_add(&t3,&(P->x),&(P->y));	//t3.add(y);
+    FP4_YYY_norm(&t3);				//t3.norm();          //t3=X1+Y1
+    FP4_YYY_add(&t4,&(Q->x),&(Q->y));	//t4.add(Q.y);
+    FP4_YYY_norm(&t4);				//t4.norm();			//t4=X2+Y2
+    FP4_YYY_mul(&t3,&t3,&t4);		//t3.mul(t4);						//t3=(X1+Y1)(X2+Y2)
+    FP4_YYY_add(&t4,&t0,&t1);		//t4.add(t1);		//t4=X1.X2+Y1.Y2
 
-	FP4_YYY_sub(&t3,&t3,&t4);		//t3.sub(t4); 
-	FP4_YYY_norm(&t3);				//t3.norm(); 
+    FP4_YYY_sub(&t3,&t3,&t4);		//t3.sub(t4);
+    FP4_YYY_norm(&t3);				//t3.norm();
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP4_YYY_times_i(&t3);			//t3.mul_ip();  //t3=(X1+Y1)(X2+Y2)-(X1.X2+Y1.Y2) = X1.Y2+X2.Y1      
-#endif
-                   
-	FP4_YYY_add(&t4,&(P->y),&(P->z));	//t4.add(z); 
-	FP4_YYY_norm(&t4);				//t4.norm();			//t4=Y1+Z1
-
-	FP4_YYY_add(&x3,&(Q->y),&(Q->z));	//x3.add(Q.z); 
-	FP4_YYY_norm(&x3);				//x3.norm();			//x3=Y2+Z2
-
-	FP4_YYY_mul(&t4,&t4,&x3);		//t4.mul(x3);						//t4=(Y1+Z1)(Y2+Z2)
-
-	FP4_YYY_add(&x3,&t1,&t2);		//x3.add(t2);						//X3=Y1.Y2+Z1.Z2
-	
-	FP4_YYY_sub(&t4,&t4,&x3);		//t4.sub(x3); 
-	FP4_YYY_norm(&t4);				//t4.norm(); 
-#if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP4_YYY_times_i(&t4);			//t4.mul_ip(); //t4=(Y1+Z1)(Y2+Z2) - (Y1.Y2+Z1.Z2) = Y1.Z2+Y2.Z1      
+    FP4_YYY_times_i(&t3);			//t3.mul_ip();  //t3=(X1+Y1)(X2+Y2)-(X1.X2+Y1.Y2) = X1.Y2+X2.Y1
 #endif
 
-	FP4_YYY_add(&x3,&(P->x),&(P->z));	//x3.add(z); 
-	FP4_YYY_norm(&x3);				//x3.norm();	// x3=X1+Z1
-		
-	FP4_YYY_add(&y3,&(Q->x),&(Q->z));	//y3.add(Q.z); 
-	FP4_YYY_norm(&y3);				//y3.norm();				// y3=X2+Z2
-	FP4_YYY_mul(&x3,&x3,&y3);		//x3.mul(y3);							// x3=(X1+Z1)(X2+Z2)
+    FP4_YYY_add(&t4,&(P->y),&(P->z));	//t4.add(z);
+    FP4_YYY_norm(&t4);				//t4.norm();			//t4=Y1+Z1
 
-	FP4_YYY_add(&y3,&t0,&t2);		//y3.add(t2);							// y3=X1.X2+Z1+Z2
-	FP4_YYY_sub(&y3,&x3,&y3);		//y3.rsub(x3); 
-	FP4_YYY_norm(&y3);				//y3.norm();				// y3=(X1+Z1)(X2+Z2) - (X1.X2+Z1.Z2) = X1.Z2+X2.Z1
+    FP4_YYY_add(&x3,&(Q->y),&(Q->z));	//x3.add(Q.z);
+    FP4_YYY_norm(&x3);				//x3.norm();			//x3=Y2+Z2
+
+    FP4_YYY_mul(&t4,&t4,&x3);		//t4.mul(x3);						//t4=(Y1+Z1)(Y2+Z2)
+
+    FP4_YYY_add(&x3,&t1,&t2);		//x3.add(t2);						//X3=Y1.Y2+Z1.Z2
+
+    FP4_YYY_sub(&t4,&t4,&x3);		//t4.sub(x3);
+    FP4_YYY_norm(&t4);				//t4.norm();
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP4_YYY_times_i(&t0);			//t0.mul_ip(); 
-	FP4_YYY_times_i(&t1);			//t1.mul_ip(); 
+    FP4_YYY_times_i(&t4);			//t4.mul_ip(); //t4=(Y1+Z1)(Y2+Z2) - (Y1.Y2+Z1.Z2) = Y1.Z2+Y2.Z1
 #endif
 
-	FP4_YYY_add(&x3,&t0,&t0);		//x3.add(t0); 
-	FP4_YYY_add(&t0,&t0,&x3);		//t0.add(x3); 
-	FP4_YYY_norm(&t0);				//t0.norm();
-	FP4_YYY_imul(&t2,&t2,b3);		//t2.imul(b); 	
+    FP4_YYY_add(&x3,&(P->x),&(P->z));	//x3.add(z);
+    FP4_YYY_norm(&x3);				//x3.norm();	// x3=X1+Z1
+
+    FP4_YYY_add(&y3,&(Q->x),&(Q->z));	//y3.add(Q.z);
+    FP4_YYY_norm(&y3);				//y3.norm();				// y3=X2+Z2
+    FP4_YYY_mul(&x3,&x3,&y3);		//x3.mul(y3);							// x3=(X1+Z1)(X2+Z2)
+
+    FP4_YYY_add(&y3,&t0,&t2);		//y3.add(t2);							// y3=X1.X2+Z1+Z2
+    FP4_YYY_sub(&y3,&x3,&y3);		//y3.rsub(x3);
+    FP4_YYY_norm(&y3);				//y3.norm();				// y3=(X1+Z1)(X2+Z2) - (X1.X2+Z1.Z2) = X1.Z2+X2.Z1
+#if SEXTIC_TWIST_ZZZ==D_TYPE
+    FP4_YYY_times_i(&t0);			//t0.mul_ip();
+    FP4_YYY_times_i(&t1);			//t1.mul_ip();
+#endif
+
+    FP4_YYY_add(&x3,&t0,&t0);		//x3.add(t0);
+    FP4_YYY_add(&t0,&t0,&x3);		//t0.add(x3);
+    FP4_YYY_norm(&t0);				//t0.norm();
+    FP4_YYY_imul(&t2,&t2,b3);		//t2.imul(b);
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-	FP4_YYY_times_i(&t2);
+    FP4_YYY_times_i(&t2);
 #endif
 
-	FP4_YYY_add(&z3,&t1,&t2);		//z3.add(t2); 
-	FP4_YYY_norm(&z3);				//z3.norm();
-	FP4_YYY_sub(&t1,&t1,&t2);		//t1.sub(t2); 
-	FP4_YYY_norm(&t1);				//t1.norm(); 
-	FP4_YYY_imul(&y3,&y3,b3);		//y3.imul(b); 
+    FP4_YYY_add(&z3,&t1,&t2);		//z3.add(t2);
+    FP4_YYY_norm(&z3);				//z3.norm();
+    FP4_YYY_sub(&t1,&t1,&t2);		//t1.sub(t2);
+    FP4_YYY_norm(&t1);				//t1.norm();
+    FP4_YYY_imul(&y3,&y3,b3);		//y3.imul(b);
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-	FP4_YYY_times_i(&y3);
+    FP4_YYY_times_i(&y3);
 #endif
 
-	FP4_YYY_mul(&x3,&y3,&t4);		//x3.mul(t4); 
+    FP4_YYY_mul(&x3,&y3,&t4);		//x3.mul(t4);
 
-	FP4_YYY_mul(&t2,&t3,&t1);		//t2.mul(t1); 
-	FP4_YYY_sub(&(P->x),&t2,&x3);		//x3.rsub(t2);
-	FP4_YYY_mul(&y3,&y3,&t0);		//y3.mul(t0); 
-	FP4_YYY_mul(&t1,&t1,&z3);		//t1.mul(z3); 
-	FP4_YYY_add(&(P->y),&y3,&t1);		//y3.add(t1);
-	FP4_YYY_mul(&t0,&t0,&t3);		//t0.mul(t3); 
-	FP4_YYY_mul(&z3,&z3,&t4);		//z3.mul(t4); 
-	FP4_YYY_add(&(P->z),&z3,&t0);		//z3.add(t0);
+    FP4_YYY_mul(&t2,&t3,&t1);		//t2.mul(t1);
+    FP4_YYY_sub(&(P->x),&t2,&x3);		//x3.rsub(t2);
+    FP4_YYY_mul(&y3,&y3,&t0);		//y3.mul(t0);
+    FP4_YYY_mul(&t1,&t1,&z3);		//t1.mul(z3);
+    FP4_YYY_add(&(P->y),&y3,&t1);		//y3.add(t1);
+    FP4_YYY_mul(&t0,&t0,&t3);		//t0.mul(t3);
+    FP4_YYY_mul(&z3,&z3,&t4);		//z3.mul(t4);
+    FP4_YYY_add(&(P->z),&z3,&t0);		//z3.add(t0);
 
 
-	FP4_YYY_norm(&(P->x));			//x.norm(); 
-	FP4_YYY_norm(&(P->y));			//y.norm();
-	FP4_YYY_norm(&(P->z));			//z.norm();
+    FP4_YYY_norm(&(P->x));			//x.norm();
+    FP4_YYY_norm(&(P->y));			//y.norm();
+    FP4_YYY_norm(&(P->z));			//z.norm();
 
     return 0;
 }
@@ -458,18 +458,18 @@
 /* SU= 16 */
 void ECP4_ZZZ_sub(ECP4_ZZZ *P,ECP4_ZZZ *Q)
 {
-	ECP4_ZZZ NQ;
-	ECP4_ZZZ_copy(&NQ,Q);
-	ECP4_ZZZ_neg(&NQ);
+    ECP4_ZZZ NQ;
+    ECP4_ZZZ_copy(&NQ,Q);
+    ECP4_ZZZ_neg(&NQ);
     ECP4_ZZZ_add(P,&NQ);
 }
 
 
 void ECP4_ZZZ_reduce(ECP4_ZZZ *P)
 {
-	FP4_YYY_reduce(&(P->x));
-	FP4_YYY_reduce(&(P->y));
-	FP4_YYY_reduce(&(P->z));
+    FP4_YYY_reduce(&(P->x));
+    FP4_YYY_reduce(&(P->y));
+    FP4_YYY_reduce(&(P->z));
 }
 
 /* P*=e */
@@ -532,65 +532,65 @@
         ECP4_ZZZ_add(P,&Q);
     }
     ECP4_ZZZ_sub(P,&C); /* apply correction */
-	ECP4_ZZZ_affine(P);
+    ECP4_ZZZ_affine(P);
 }
 
-// calculate frobenius constants 
+// calculate frobenius constants
 void ECP4_ZZZ_frob_constants(FP2_YYY F[3])
 {
     FP_YYY fx,fy;
-	FP2_YYY X;
+    FP2_YYY X;
 
     FP_YYY_rcopy(&fx,Fra_YYY);
     FP_YYY_rcopy(&fy,Frb_YYY);
     FP2_YYY_from_FPs(&X,&fx,&fy);
 
-	FP2_YYY_sqr(&F[0],&X);		// FF=F^2=(1+i)^(p-7)/6
-	FP2_YYY_copy(&F[2],&F[0]);
-	FP2_YYY_mul_ip(&F[2]);		// W=(1+i)^6/6.(1+i)^(p-7)/6 = (1+i)^(p-1)/6
-	FP2_YYY_norm(&F[2]);
-	FP2_YYY_sqr(&F[1],&F[2]);
-	FP2_YYY_mul(&F[2],&F[2],&F[1]);  // W=(1+i)^(p-1)/2
+    FP2_YYY_sqr(&F[0],&X);		// FF=F^2=(1+i)^(p-7)/6
+    FP2_YYY_copy(&F[2],&F[0]);
+    FP2_YYY_mul_ip(&F[2]);		// W=(1+i)^6/6.(1+i)^(p-7)/6 = (1+i)^(p-1)/6
+    FP2_YYY_norm(&F[2]);
+    FP2_YYY_sqr(&F[1],&F[2]);
+    FP2_YYY_mul(&F[2],&F[2],&F[1]);  // W=(1+i)^(p-1)/2
 
-	FP2_YYY_copy(&F[1],&X);
+    FP2_YYY_copy(&F[1],&X);
 
-#if SEXTIC_TWIST_ZZZ == M_TYPE	
-	FP2_YYY_mul_ip(&F[1]);		// (1+i)^12/12.(1+i)^(p-7)/12 = (1+i)^(p+5)/12
-	FP2_YYY_inv(&F[1],&F[1]);		// (1+i)^-(p+5)/12
-	FP2_YYY_sqr(&F[0],&F[1]);		// (1+i)^-(p+5)/6
+#if SEXTIC_TWIST_ZZZ == M_TYPE
+    FP2_YYY_mul_ip(&F[1]);		// (1+i)^12/12.(1+i)^(p-7)/12 = (1+i)^(p+5)/12
+    FP2_YYY_inv(&F[1],&F[1]);		// (1+i)^-(p+5)/12
+    FP2_YYY_sqr(&F[0],&F[1]);		// (1+i)^-(p+5)/6
 #endif
 
-	FP2_YYY_mul_ip(&F[0]);		// FF=(1+i)^(p-7)/6.(1+i) = (1+i)^(p-1)/6					// (1+i)^6/6.(1+i)^-(p+5)/6 = (1+i)^-(p-1)/6
-	FP2_YYY_norm(&F[0]);
-	FP2_YYY_mul(&F[1],&F[1],&F[0]);  // FFF = (1+i)^(p-7)/12 . (1+i)^(p-1)/6 = (1+i)^(p-3)/4	// (1+i)^-(p+5)/12 . (1+i)^-(p-1)/6 = (1+i)^-(p+1)/4
+    FP2_YYY_mul_ip(&F[0]);		// FF=(1+i)^(p-7)/6.(1+i) = (1+i)^(p-1)/6					// (1+i)^6/6.(1+i)^-(p+5)/6 = (1+i)^-(p-1)/6
+    FP2_YYY_norm(&F[0]);
+    FP2_YYY_mul(&F[1],&F[1],&F[0]);  // FFF = (1+i)^(p-7)/12 . (1+i)^(p-1)/6 = (1+i)^(p-3)/4	// (1+i)^-(p+5)/12 . (1+i)^-(p-1)/6 = (1+i)^-(p+1)/4
 
 }
 
 /* Calculates q^n.P using Frobenius constants */
 void ECP4_ZZZ_frob(ECP4_ZZZ *P,FP2_YYY F[3],int n)
 {
-	int i;
-	FP4_YYY X,Y,Z;
+    int i;
+    FP4_YYY X,Y,Z;
 
-	FP4_YYY_copy(&X,&(P->x));
-	FP4_YYY_copy(&Y,&(P->y));
-	FP4_YYY_copy(&Z,&(P->z));
+    FP4_YYY_copy(&X,&(P->x));
+    FP4_YYY_copy(&Y,&(P->y));
+    FP4_YYY_copy(&Z,&(P->z));
 
-	for (i=0;i<n;i++)
-	{
-		FP4_YYY_frob(&X,&F[2]);		// X^p
-		FP4_YYY_pmul(&X,&X,&F[0]);	// X^p.(1+i)^(p-1)/6									// X^p.(1+i)^-(p-1)/6
-		
-		FP4_YYY_frob(&Y,&F[2]);		// Y^p
-		FP4_YYY_pmul(&Y,&Y,&F[1]);
-		FP4_YYY_times_i(&Y);		// Y.p.(1+i)^(p-3)/4.(1+i)^(2/4) = Y^p.(1+i)^(p-1)/4	// (1+i)^-(p+1)/4 .(1+i)^2/4 = Y^p.(1+i)^-(p-1)/4
+    for (i=0; i<n; i++)
+    {
+        FP4_YYY_frob(&X,&F[2]);		// X^p
+        FP4_YYY_pmul(&X,&X,&F[0]);	// X^p.(1+i)^(p-1)/6									// X^p.(1+i)^-(p-1)/6
 
-		FP4_YYY_frob(&Z,&F[2]);
-	}
+        FP4_YYY_frob(&Y,&F[2]);		// Y^p
+        FP4_YYY_pmul(&Y,&Y,&F[1]);
+        FP4_YYY_times_i(&Y);		// Y.p.(1+i)^(p-3)/4.(1+i)^(2/4) = Y^p.(1+i)^(p-1)/4	// (1+i)^-(p+1)/4 .(1+i)^2/4 = Y^p.(1+i)^-(p-1)/4
 
-	FP4_YYY_copy(&(P->x),&X);
-	FP4_YYY_copy(&(P->y),&Y);
-	FP4_YYY_copy(&(P->z),&Z);
+        FP4_YYY_frob(&Z,&F[2]);
+    }
+
+    FP4_YYY_copy(&(P->x),&X);
+    FP4_YYY_copy(&(P->y),&Y);
+    FP4_YYY_copy(&(P->z),&Z);
 }
 
 /* Side channel attack secure */
@@ -600,54 +600,54 @@
 void ECP4_ZZZ_mul8(ECP4_ZZZ *P,ECP4_ZZZ Q[8],BIG_XXX u[8])
 {
     int i,j,k,nb,pb1,pb2,bt;
-	ECP4_ZZZ T1[8],T2[8],W;
+    ECP4_ZZZ T1[8],T2[8],W;
     BIG_XXX mt,t[8];
     sign8 w1[NLEN_XXX*BASEBITS_XXX+1];
     sign8 s1[NLEN_XXX*BASEBITS_XXX+1];
     sign8 w2[NLEN_XXX*BASEBITS_XXX+1];
-    sign8 s2[NLEN_XXX*BASEBITS_XXX+1];	
-	FP2_YYY X[3];
+    sign8 s2[NLEN_XXX*BASEBITS_XXX+1];
+    FP2_YYY X[3];
 
-	ECP4_ZZZ_frob_constants(X);
+    ECP4_ZZZ_frob_constants(X);
 
     for (i=0; i<8; i++)
-	{
+    {
         BIG_XXX_copy(t[i],u[i]);
-	}
+    }
 
 // Precomputed table
     ECP4_ZZZ_copy(&T1[0],&Q[0]); // Q[0]
     ECP4_ZZZ_copy(&T1[1],&T1[0]);
-	ECP4_ZZZ_add(&T1[1],&Q[1]);	// Q[0]+Q[1]
+    ECP4_ZZZ_add(&T1[1],&Q[1]);	// Q[0]+Q[1]
     ECP4_ZZZ_copy(&T1[2],&T1[0]);
-	ECP4_ZZZ_add(&T1[2],&Q[2]);	// Q[0]+Q[2]
-	ECP4_ZZZ_copy(&T1[3],&T1[1]);
-	ECP4_ZZZ_add(&T1[3],&Q[2]);	// Q[0]+Q[1]+Q[2]
-	ECP4_ZZZ_copy(&T1[4],&T1[0]);
-	ECP4_ZZZ_add(&T1[4],&Q[3]);  // Q[0]+Q[3]
-	ECP4_ZZZ_copy(&T1[5],&T1[1]);
-	ECP4_ZZZ_add(&T1[5],&Q[3]);	// Q[0]+Q[1]+Q[3]
-	ECP4_ZZZ_copy(&T1[6],&T1[2]);
-	ECP4_ZZZ_add(&T1[6],&Q[3]);	// Q[0]+Q[2]+Q[3]
-	ECP4_ZZZ_copy(&T1[7],&T1[3]);
-	ECP4_ZZZ_add(&T1[7],&Q[3]);	// Q[0]+Q[1]+Q[2]+Q[3]
+    ECP4_ZZZ_add(&T1[2],&Q[2]);	// Q[0]+Q[2]
+    ECP4_ZZZ_copy(&T1[3],&T1[1]);
+    ECP4_ZZZ_add(&T1[3],&Q[2]);	// Q[0]+Q[1]+Q[2]
+    ECP4_ZZZ_copy(&T1[4],&T1[0]);
+    ECP4_ZZZ_add(&T1[4],&Q[3]);  // Q[0]+Q[3]
+    ECP4_ZZZ_copy(&T1[5],&T1[1]);
+    ECP4_ZZZ_add(&T1[5],&Q[3]);	// Q[0]+Q[1]+Q[3]
+    ECP4_ZZZ_copy(&T1[6],&T1[2]);
+    ECP4_ZZZ_add(&T1[6],&Q[3]);	// Q[0]+Q[2]+Q[3]
+    ECP4_ZZZ_copy(&T1[7],&T1[3]);
+    ECP4_ZZZ_add(&T1[7],&Q[3]);	// Q[0]+Q[1]+Q[2]+Q[3]
 
-//  Use Frobenius 
+//  Use Frobenius
 
-	for (i=0;i<8;i++)
-	{
-		ECP4_ZZZ_copy(&T2[i],&T1[i]);
-		ECP4_ZZZ_frob(&T2[i],X,4);
-	}
+    for (i=0; i<8; i++)
+    {
+        ECP4_ZZZ_copy(&T2[i],&T1[i]);
+        ECP4_ZZZ_frob(&T2[i],X,4);
+    }
 
 // Make them odd
-	pb1=1-BIG_XXX_parity(t[0]);
-	BIG_XXX_inc(t[0],pb1);
-	BIG_XXX_norm(t[0]);
+    pb1=1-BIG_XXX_parity(t[0]);
+    BIG_XXX_inc(t[0],pb1);
+    BIG_XXX_norm(t[0]);
 
-	pb2=1-BIG_XXX_parity(t[4]);
-	BIG_XXX_inc(t[4],pb2);
-	BIG_XXX_norm(t[4]);
+    pb2=1-BIG_XXX_parity(t[4]);
+    BIG_XXX_inc(t[4],pb2);
+    BIG_XXX_norm(t[4]);
 
 // Number of bits
     BIG_XXX_zero(mt);
@@ -657,52 +657,52 @@
     }
     nb=1+BIG_XXX_nbits(mt);
 
-// Sign pivot 
-	s1[nb-1]=1;
-	s2[nb-1]=1;
-	for (i=0;i<nb-1;i++)
-	{
+// Sign pivot
+    s1[nb-1]=1;
+    s2[nb-1]=1;
+    for (i=0; i<nb-1; i++)
+    {
         BIG_XXX_fshr(t[0],1);
-		s1[i]=2*BIG_XXX_parity(t[0])-1;
+        s1[i]=2*BIG_XXX_parity(t[0])-1;
         BIG_XXX_fshr(t[4],1);
-		s2[i]=2*BIG_XXX_parity(t[4])-1;
-	}
+        s2[i]=2*BIG_XXX_parity(t[4])-1;
+    }
 
 
 // Recoded exponents
     for (i=0; i<nb; i++)
     {
-		w1[i]=0;
-		k=1;
-		for (j=1; j<4; j++)
-		{
-			bt=s1[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w1[i]=0;
+        k=1;
+        for (j=1; j<4; j++)
+        {
+            bt=s1[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w1[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w1[i]+=bt*k;
+            k*=2;
         }
 
-		w2[i]=0;
-		k=1;
-		for (j=5; j<8; j++)
-		{
-			bt=s2[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w2[i]=0;
+        k=1;
+        for (j=5; j<8; j++)
+        {
+            bt=s2[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w2[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w2[i]+=bt*k;
+            k*=2;
         }
-    }	
+    }
 
 // Main loop
-	ECP4_ZZZ_select(P,T1,2*w1[nb-1]+1);
-	ECP4_ZZZ_select(&W,T2,2*w2[nb-1]+1);
-	ECP4_ZZZ_add(P,&W);
+    ECP4_ZZZ_select(P,T1,2*w1[nb-1]+1);
+    ECP4_ZZZ_select(&W,T2,2*w2[nb-1]+1);
+    ECP4_ZZZ_add(P,&W);
     for (i=nb-2; i>=0; i--)
     {
         ECP4_ZZZ_dbl(P);
@@ -713,14 +713,14 @@
     }
 
 // apply corrections
-	ECP4_ZZZ_copy(&W,P);   
-	ECP4_ZZZ_sub(&W,&Q[0]);
-	ECP4_ZZZ_cmove(P,&W,pb1);
-	ECP4_ZZZ_copy(&W,P);   
-	ECP4_ZZZ_sub(&W,&Q[4]);
-	ECP4_ZZZ_cmove(P,&W,pb2);
+    ECP4_ZZZ_copy(&W,P);
+    ECP4_ZZZ_sub(&W,&Q[0]);
+    ECP4_ZZZ_cmove(P,&W,pb1);
+    ECP4_ZZZ_copy(&W,P);
+    ECP4_ZZZ_sub(&W,&Q[4]);
+    ECP4_ZZZ_cmove(P,&W,pb2);
 
-	ECP4_ZZZ_affine(P);
+    ECP4_ZZZ_affine(P);
 }
 
 /* Map to hash value to point on G2 from random BIG_XXX */
@@ -729,11 +729,11 @@
 {
     BIG_XXX q,one,x,hv;
     FP2_YYY X[3],T;
-	FP4_YYY X4,Y4;
+    FP4_YYY X4;
 
     ECP4_ZZZ xQ, x2Q, x3Q, x4Q;
 
-	BIG_XXX_fromBytes(hv,W->val);
+    BIG_XXX_fromBytes(hv,W->val);
     BIG_XXX_rcopy(q,Modulus_YYY);
     BIG_XXX_one(one);
     BIG_XXX_mod(hv,q);
@@ -741,53 +741,53 @@
     for (;;)
     {
         FP2_YYY_from_BIGs(&T,one,hv);  /*******/
-		FP4_YYY_from_FP2(&X4,&T);
+        FP4_YYY_from_FP2(&X4,&T);
         if (ECP4_ZZZ_setx(Q,&X4)) break;
         BIG_XXX_inc(hv,1);
     }
 
-	ECP4_ZZZ_frob_constants(X);
+    ECP4_ZZZ_frob_constants(X);
 
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
 
-    // Efficient hash maps to G2 on BLS24 curves - Budroni, Pintore 
-	// Q -> x4Q -x3Q -Q + F(x3Q-x2Q) + F(F(x2Q-xQ)) + F(F(F(xQ-Q))) +F(F(F(F(2Q))))
+    // Efficient hash maps to G2 on BLS24 curves - Budroni, Pintore
+    // Q -> x4Q -x3Q -Q + F(x3Q-x2Q) + F(F(x2Q-xQ)) + F(F(F(xQ-Q))) +F(F(F(F(2Q))))
 
-	ECP4_ZZZ_copy(&xQ,Q);
-	ECP4_ZZZ_mul(&xQ,x);
-	ECP4_ZZZ_copy(&x2Q,&xQ);
-	ECP4_ZZZ_mul(&x2Q,x);
-	ECP4_ZZZ_copy(&x3Q,&x2Q);
-	ECP4_ZZZ_mul(&x3Q,x);
-	ECP4_ZZZ_copy(&x4Q,&x3Q);
-	ECP4_ZZZ_mul(&x4Q,x);
+    ECP4_ZZZ_copy(&xQ,Q);
+    ECP4_ZZZ_mul(&xQ,x);
+    ECP4_ZZZ_copy(&x2Q,&xQ);
+    ECP4_ZZZ_mul(&x2Q,x);
+    ECP4_ZZZ_copy(&x3Q,&x2Q);
+    ECP4_ZZZ_mul(&x3Q,x);
+    ECP4_ZZZ_copy(&x4Q,&x3Q);
+    ECP4_ZZZ_mul(&x4Q,x);
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	ECP4_ZZZ_neg(&xQ);
-	ECP4_ZZZ_neg(&x3Q);
+    ECP4_ZZZ_neg(&xQ);
+    ECP4_ZZZ_neg(&x3Q);
 #endif
 
-	ECP4_ZZZ_sub(&x4Q,&x3Q);
-	ECP4_ZZZ_sub(&x4Q,Q);
+    ECP4_ZZZ_sub(&x4Q,&x3Q);
+    ECP4_ZZZ_sub(&x4Q,Q);
 
-	ECP4_ZZZ_sub(&x3Q,&x2Q);
-	ECP4_ZZZ_frob(&x3Q,X,1);
+    ECP4_ZZZ_sub(&x3Q,&x2Q);
+    ECP4_ZZZ_frob(&x3Q,X,1);
 
-	ECP4_ZZZ_sub(&x2Q,&xQ);
-	ECP4_ZZZ_frob(&x2Q,X,2);
+    ECP4_ZZZ_sub(&x2Q,&xQ);
+    ECP4_ZZZ_frob(&x2Q,X,2);
 
-	ECP4_ZZZ_sub(&xQ,Q);
-	ECP4_ZZZ_frob(&xQ,X,3);
+    ECP4_ZZZ_sub(&xQ,Q);
+    ECP4_ZZZ_frob(&xQ,X,3);
 
-	ECP4_ZZZ_dbl(Q);
-	ECP4_ZZZ_frob(Q,X,4);
+    ECP4_ZZZ_dbl(Q);
+    ECP4_ZZZ_frob(Q,X,4);
 
-	ECP4_ZZZ_add(Q,&x4Q);
-	ECP4_ZZZ_add(Q,&x3Q);
-	ECP4_ZZZ_add(Q,&x2Q);
-	ECP4_ZZZ_add(Q,&xQ);
+    ECP4_ZZZ_add(Q,&x4Q);
+    ECP4_ZZZ_add(Q,&x3Q);
+    ECP4_ZZZ_add(Q,&x2Q);
+    ECP4_ZZZ_add(Q,&xQ);
 
-	ECP4_ZZZ_affine(Q);
+    ECP4_ZZZ_affine(Q);
 
 }
 
@@ -795,30 +795,30 @@
 
 void ECP4_ZZZ_generator(ECP4_ZZZ *G)
 {
-	BIG_XXX a,b;
-	FP2_YYY Aa,Bb;
-	FP4_YYY X,Y;
+    BIG_XXX a,b;
+    FP2_YYY Aa,Bb;
+    FP4_YYY X,Y;
 
-	BIG_XXX_rcopy(a,CURVE_Pxaa_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pxab_ZZZ);
-	FP2_YYY_from_BIGs(&Aa,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pxaa_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pxab_ZZZ);
+    FP2_YYY_from_BIGs(&Aa,a,b);
 
-	BIG_XXX_rcopy(a,CURVE_Pxba_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pxbb_ZZZ);
-	FP2_YYY_from_BIGs(&Bb,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pxba_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pxbb_ZZZ);
+    FP2_YYY_from_BIGs(&Bb,a,b);
 
-	FP4_YYY_from_FP2s(&X,&Aa,&Bb);
+    FP4_YYY_from_FP2s(&X,&Aa,&Bb);
 
-	BIG_XXX_rcopy(a,CURVE_Pyaa_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pyab_ZZZ);
-	FP2_YYY_from_BIGs(&Aa,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pyaa_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pyab_ZZZ);
+    FP2_YYY_from_BIGs(&Aa,a,b);
 
-	BIG_XXX_rcopy(a,CURVE_Pyba_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pybb_ZZZ);
-	FP2_YYY_from_BIGs(&Bb,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pyba_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pybb_ZZZ);
+    FP2_YYY_from_BIGs(&Bb,a,b);
 
-	FP4_YYY_from_FP2s(&Y,&Aa,&Bb);
+    FP4_YYY_from_FP2s(&Y,&Aa,&Bb);
 
-	ECP4_ZZZ_set(G,&X,&Y);
+    ECP4_ZZZ_set(G,&X,&Y);
 }
 
diff --git a/version3/c/ecp4.h b/version3/c/ecp4.h
index 8e022c9..5a0b756 100644
--- a/version3/c/ecp4.h
+++ b/version3/c/ecp4.h
@@ -11,10 +11,10 @@
 
 typedef struct
 {
- //   int inf; /**< Infinity Flag */
+//   int inf; /**< Infinity Flag */
     FP4_YYY x;   /**< x-coordinate of point */
     FP4_YYY y;   /**< y-coordinate of point */
-	FP4_YYY z;
+    FP4_YYY z;
 } ECP4_ZZZ;
 
 
diff --git a/version3/c/ecp8.c b/version3/c/ecp8.c
index dff3594..f807da2 100644
--- a/version3/c/ecp8.c
+++ b/version3/c/ecp8.c
@@ -25,7 +25,7 @@
 
 int ECP8_ZZZ_isinf(ECP8_ZZZ *P)
 {
-	return (FP8_YYY_iszilch(&(P->x)) & FP8_YYY_iszilch(&(P->z)));
+    return (FP8_YYY_iszilch(&(P->x)) & FP8_YYY_iszilch(&(P->z)));
 }
 
 /* Set P=Q */
@@ -41,7 +41,7 @@
 {
     FP8_YYY_zero(&(P->x));
     FP8_YYY_one(&(P->y));
-	FP8_YYY_zero(&(P->z));
+    FP8_YYY_zero(&(P->z));
 }
 
 /* Conditional move Q to P dependant on d */
@@ -125,9 +125,9 @@
 /* extract x, y from point P */
 int ECP8_ZZZ_get(FP8_YYY *x,FP8_YYY *y,ECP8_ZZZ *P)
 {
-	ECP8_ZZZ W;
-	ECP8_ZZZ_copy(&W,P);
-	ECP8_ZZZ_affine(&W);
+    ECP8_ZZZ W;
+    ECP8_ZZZ_copy(&W,P);
+    ECP8_ZZZ_affine(&W);
     if (ECP8_ZZZ_isinf(&W)) return -1;
     FP8_YYY_copy(y,&(W.y));
     FP8_YYY_copy(x,&(W.x));
@@ -154,20 +154,20 @@
 /* Convert Q to octet string */
 void ECP8_ZZZ_toOctet(octet *W,ECP8_ZZZ *Q)
 {
-	BIG_XXX b;
-	FP8_YYY qx,qy;
-	FP4_YYY qa,qb;
-	FP2_YYY pa,pb;
+    BIG_XXX b;
+    FP8_YYY qx,qy;
+    FP4_YYY qa,qb;
+    FP2_YYY pa,pb;
 
     ECP8_ZZZ_get(&qx,&qy,Q);
 
-	FP4_YYY_copy(&qa,&(qx.a));
-	FP4_YYY_copy(&qb,&(qx.b));
+    FP4_YYY_copy(&qa,&(qx.a));
+    FP4_YYY_copy(&qb,&(qx.b));
 
-	FP2_YYY_copy(&pa,&(qa.a));
-	FP2_YYY_copy(&pb,&(qa.b));
+    FP2_YYY_copy(&pa,&(qa.a));
+    FP2_YYY_copy(&pb,&(qa.b));
 
-	FP_YYY_redc(b,&(pa.a));
+    FP_YYY_redc(b,&(pa.a));
     BIG_XXX_toBytes(&(W->val[0]),b);
     FP_YYY_redc(b,&(pa.b));
     BIG_XXX_toBytes(&(W->val[MODBYTES_XXX]),b);
@@ -176,10 +176,10 @@
     FP_YYY_redc(b,&(pb.b));
     BIG_XXX_toBytes(&(W->val[3*MODBYTES_XXX]),b);
 
-	FP2_YYY_copy(&pa,&(qb.a));
-	FP2_YYY_copy(&pb,&(qb.b));
+    FP2_YYY_copy(&pa,&(qb.a));
+    FP2_YYY_copy(&pb,&(qb.b));
 
-	FP_YYY_redc(b,&(pa.a));
+    FP_YYY_redc(b,&(pa.a));
     BIG_XXX_toBytes(&(W->val[4*MODBYTES_XXX]),b);
     FP_YYY_redc(b,&(pa.b));
     BIG_XXX_toBytes(&(W->val[5*MODBYTES_XXX]),b);
@@ -189,13 +189,13 @@
     BIG_XXX_toBytes(&(W->val[7*MODBYTES_XXX]),b);
 
 
-	FP4_YYY_copy(&qa,&(qy.a));
-	FP4_YYY_copy(&qb,&(qy.b));
+    FP4_YYY_copy(&qa,&(qy.a));
+    FP4_YYY_copy(&qb,&(qy.b));
 
-	FP2_YYY_copy(&pa,&(qa.a));
-	FP2_YYY_copy(&pb,&(qa.b));
+    FP2_YYY_copy(&pa,&(qa.a));
+    FP2_YYY_copy(&pb,&(qa.b));
 
-	FP_YYY_redc(b,&(pa.a));
+    FP_YYY_redc(b,&(pa.a));
     BIG_XXX_toBytes(&(W->val[8*MODBYTES_XXX]),b);
     FP_YYY_redc(b,&(pa.b));
     BIG_XXX_toBytes(&(W->val[9*MODBYTES_XXX]),b);
@@ -204,10 +204,10 @@
     FP_YYY_redc(b,&(pb.b));
     BIG_XXX_toBytes(&(W->val[11*MODBYTES_XXX]),b);
 
-	FP2_YYY_copy(&pa,&(qb.a));
-	FP2_YYY_copy(&pb,&(qb.b));
+    FP2_YYY_copy(&pa,&(qb.a));
+    FP2_YYY_copy(&pb,&(qb.b));
 
-	FP_YYY_redc(b,&(pa.a));
+    FP_YYY_redc(b,&(pa.a));
     BIG_XXX_toBytes(&(W->val[12*MODBYTES_XXX]),b);
     FP_YYY_redc(b,&(pa.b));
     BIG_XXX_toBytes(&(W->val[13*MODBYTES_XXX]),b);
@@ -223,13 +223,13 @@
 /* restore Q from octet string */
 int ECP8_ZZZ_fromOctet(ECP8_ZZZ *Q,octet *W)
 {
-	BIG_XXX b;
+    BIG_XXX b;
     FP8_YYY qx,qy;
-	FP4_YYY qa,qb;
-	FP2_YYY pa,pb;
+    FP4_YYY qa,qb;
+    FP2_YYY pa,pb;
 
     BIG_XXX_fromBytes(b,&(W->val[0]));
-	FP_YYY_nres(&(pa.a),b);
+    FP_YYY_nres(&(pa.a),b);
     BIG_XXX_fromBytes(b,&(W->val[MODBYTES_XXX]));
     FP_YYY_nres(&(pa.b),b);
     BIG_XXX_fromBytes(b,&(W->val[2*MODBYTES_XXX]));
@@ -237,11 +237,11 @@
     BIG_XXX_fromBytes(b,&(W->val[3*MODBYTES_XXX]));
     FP_YYY_nres(&(pb.b),b);
 
-	FP2_YYY_copy(&(qa.a),&pa);
-	FP2_YYY_copy(&(qa.b),&pb);
+    FP2_YYY_copy(&(qa.a),&pa);
+    FP2_YYY_copy(&(qa.b),&pb);
 
     BIG_XXX_fromBytes(b,&(W->val[4*MODBYTES_XXX]));
-	FP_YYY_nres(&(pa.a),b);
+    FP_YYY_nres(&(pa.a),b);
     BIG_XXX_fromBytes(b,&(W->val[5*MODBYTES_XXX]));
     FP_YYY_nres(&(pa.b),b);
     BIG_XXX_fromBytes(b,&(W->val[6*MODBYTES_XXX]));
@@ -249,15 +249,15 @@
     BIG_XXX_fromBytes(b,&(W->val[7*MODBYTES_XXX]));
     FP_YYY_nres(&(pb.b),b);
 
-	FP2_YYY_copy(&(qb.a),&pa);
-	FP2_YYY_copy(&(qb.b),&pb);
+    FP2_YYY_copy(&(qb.a),&pa);
+    FP2_YYY_copy(&(qb.b),&pb);
 
-	FP4_YYY_copy(&(qx.a),&qa);
-	FP4_YYY_copy(&(qx.b),&qb);
+    FP4_YYY_copy(&(qx.a),&qa);
+    FP4_YYY_copy(&(qx.b),&qb);
 
 
     BIG_XXX_fromBytes(b,&(W->val[8*MODBYTES_XXX]));
-	FP_YYY_nres(&(pa.a),b);
+    FP_YYY_nres(&(pa.a),b);
     BIG_XXX_fromBytes(b,&(W->val[9*MODBYTES_XXX]));
     FP_YYY_nres(&(pa.b),b);
     BIG_XXX_fromBytes(b,&(W->val[10*MODBYTES_XXX]));
@@ -265,11 +265,11 @@
     BIG_XXX_fromBytes(b,&(W->val[11*MODBYTES_XXX]));
     FP_YYY_nres(&(pb.b),b);
 
-	FP2_YYY_copy(&(qa.a),&pa);
-	FP2_YYY_copy(&(qa.b),&pb);
+    FP2_YYY_copy(&(qa.a),&pa);
+    FP2_YYY_copy(&(qa.b),&pb);
 
     BIG_XXX_fromBytes(b,&(W->val[12*MODBYTES_XXX]));
-	FP_YYY_nres(&(pa.a),b);
+    FP_YYY_nres(&(pa.a),b);
     BIG_XXX_fromBytes(b,&(W->val[13*MODBYTES_XXX]));
     FP_YYY_nres(&(pa.b),b);
     BIG_XXX_fromBytes(b,&(W->val[14*MODBYTES_XXX]));
@@ -277,11 +277,11 @@
     BIG_XXX_fromBytes(b,&(W->val[15*MODBYTES_XXX]));
     FP_YYY_nres(&(pb.b),b);
 
-	FP2_YYY_copy(&(qb.a),&pa);
-	FP2_YYY_copy(&(qb.b),&pb);
+    FP2_YYY_copy(&(qb.a),&pa);
+    FP2_YYY_copy(&(qb.b),&pb);
 
-	FP4_YYY_copy(&(qy.a),&qa);
-	FP4_YYY_copy(&(qy.b),&qb);
+    FP4_YYY_copy(&(qy.a),&qa);
+    FP4_YYY_copy(&(qy.b),&qb);
 
 
     if (ECP8_ZZZ_set(Q,&qx,&qy)) return 1;
@@ -293,8 +293,8 @@
 {
     /* calculate RHS of elliptic curve equation */
     FP8_YYY t;
-	FP4_YYY t4;
-	FP2_YYY t2;
+    FP4_YYY t4;
+    FP2_YYY t2;
     BIG_XXX b;
     FP8_YYY_sqr(&t,x);
 
@@ -305,14 +305,14 @@
     BIG_XXX_rcopy(b,CURVE_B_ZZZ);
 
     FP2_YYY_from_BIG(&t2,b);
-	FP4_YYY_from_FP2(&t4,&t2);
-	FP8_YYY_from_FP4(&t,&t4);
+    FP4_YYY_from_FP2(&t4,&t2);
+    FP8_YYY_from_FP4(&t,&t4);
 
-#if SEXTIC_TWIST_ZZZ == D_TYPE	
+#if SEXTIC_TWIST_ZZZ == D_TYPE
     FP8_YYY_div_i(&t);   /* IMPORTANT - here we use the correct SEXTIC twist of the curve */
 #endif
 
-#if SEXTIC_TWIST_ZZZ == M_TYPE	
+#if SEXTIC_TWIST_ZZZ == M_TYPE
     FP8_YYY_times_i(&t);   /* IMPORTANT - here we use the correct SEXTIC twist of the curve */
 #endif
 
@@ -331,7 +331,7 @@
 
     if (!FP8_YYY_equals(&y2,&rhs))
     {
-		ECP8_ZZZ_inf(P);
+        ECP8_ZZZ_inf(P);
         return 0;
     }
 
@@ -351,7 +351,7 @@
 
     if (!FP8_YYY_sqrt(&y,&y))
     {
-		ECP8_ZZZ_inf(P);
+        ECP8_ZZZ_inf(P);
         return 0;
     }
 
@@ -365,7 +365,7 @@
 /* SU= 8 */
 void ECP8_ZZZ_neg(ECP8_ZZZ *P)
 {
-	FP8_YYY_norm(&(P->y));
+    FP8_YYY_norm(&(P->y));
     FP8_YYY_neg(&(P->y),&(P->y));
     FP8_YYY_norm(&(P->y));
 }
@@ -376,55 +376,55 @@
 /* return -1 for Infinity, 0 for addition, 1 for doubling */
 int ECP8_ZZZ_dbl(ECP8_ZZZ *P)
 {
-    FP8_YYY t0,t1,t2,t3,iy,x3,y3;
+    FP8_YYY t0,t1,t2,iy,x3,y3;
 
-	FP8_YYY_copy(&iy,&(P->y));		//FP8_YYY iy=new FP8_YYY(y);
+    FP8_YYY_copy(&iy,&(P->y));		//FP8_YYY iy=new FP8_YYY(y);
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP8_YYY_times_i(&iy);			//iy.mul_ip(); 
+    FP8_YYY_times_i(&iy);			//iy.mul_ip();
 #endif
 
-	FP8_YYY_sqr(&t0,&(P->y));			//t0.sqr();   
+    FP8_YYY_sqr(&t0,&(P->y));			//t0.sqr();
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP8_YYY_times_i(&t0);			//t0.mul_ip(); 
+    FP8_YYY_times_i(&t0);			//t0.mul_ip();
 #endif
 
-	FP8_YYY_mul(&t1,&iy,&(P->z));	//t1.mul(z);
-	FP8_YYY_sqr(&t2,&(P->z));				//t2.sqr();
+    FP8_YYY_mul(&t1,&iy,&(P->z));	//t1.mul(z);
+    FP8_YYY_sqr(&t2,&(P->z));				//t2.sqr();
 
-	FP8_YYY_add(&(P->z),&t0,&t0);	//z.add(t0); 
-	FP8_YYY_norm(&(P->z));				//z.norm(); 
-	FP8_YYY_add(&(P->z),&(P->z),&(P->z));	//z.add(z); 
-	FP8_YYY_add(&(P->z),&(P->z),&(P->z));	//z.add(z); 
-	FP8_YYY_norm(&(P->z));			//z.norm();  
+    FP8_YYY_add(&(P->z),&t0,&t0);	//z.add(t0);
+    FP8_YYY_norm(&(P->z));				//z.norm();
+    FP8_YYY_add(&(P->z),&(P->z),&(P->z));	//z.add(z);
+    FP8_YYY_add(&(P->z),&(P->z),&(P->z));	//z.add(z);
+    FP8_YYY_norm(&(P->z));			//z.norm();
 
-	FP8_YYY_imul(&t2,&t2,3*CURVE_B_I_ZZZ);	//t2.imul(3*ROM.CURVE_B_I); 
+    FP8_YYY_imul(&t2,&t2,3*CURVE_B_I_ZZZ);	//t2.imul(3*ROM.CURVE_B_I);
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-	FP8_YYY_times_i(&t2);
+    FP8_YYY_times_i(&t2);
 #endif
 
-	FP8_YYY_mul(&x3,&t2,&(P->z));	//x3.mul(z); 
+    FP8_YYY_mul(&x3,&t2,&(P->z));	//x3.mul(z);
 
-	FP8_YYY_add(&y3,&t0,&t2);		//y3.add(t2); 
-	FP8_YYY_norm(&y3);				//y3.norm();
-	FP8_YYY_mul(&(P->z),&(P->z),&t1);	//z.mul(t1);
+    FP8_YYY_add(&y3,&t0,&t2);		//y3.add(t2);
+    FP8_YYY_norm(&y3);				//y3.norm();
+    FP8_YYY_mul(&(P->z),&(P->z),&t1);	//z.mul(t1);
 
-	FP8_YYY_add(&t1,&t2,&t2);		//t1.add(t2); 
-	FP8_YYY_add(&t2,&t2,&t1);		//t2.add(t1); 
-	FP8_YYY_norm(&t2);				//t2.norm();  
-	FP8_YYY_sub(&t0,&t0,&t2);		//t0.sub(t2); 
-	FP8_YYY_norm(&t0);				//t0.norm();                           //y^2-9bz^2
-	FP8_YYY_mul(&y3,&y3,&t0);		//y3.mul(t0); 
-	FP8_YYY_add(&(P->y),&y3,&x3);		//y3.add(x3);                          //(y^2+3z*2)(y^2-9z^2)+3b.z^2.8y^2
+    FP8_YYY_add(&t1,&t2,&t2);		//t1.add(t2);
+    FP8_YYY_add(&t2,&t2,&t1);		//t2.add(t1);
+    FP8_YYY_norm(&t2);				//t2.norm();
+    FP8_YYY_sub(&t0,&t0,&t2);		//t0.sub(t2);
+    FP8_YYY_norm(&t0);				//t0.norm();                           //y^2-9bz^2
+    FP8_YYY_mul(&y3,&y3,&t0);		//y3.mul(t0);
+    FP8_YYY_add(&(P->y),&y3,&x3);		//y3.add(x3);                          //(y^2+3z*2)(y^2-9z^2)+3b.z^2.8y^2
 
-	FP8_YYY_mul(&t1,&(P->x),&iy);		//t1.mul(iy);						//
+    FP8_YYY_mul(&t1,&(P->x),&iy);		//t1.mul(iy);						//
 
-	FP8_YYY_norm(&t0);			//x.norm(); 
-	FP8_YYY_mul(&(P->x),&t0,&t1);	//x.mul(t1); 
-	FP8_YYY_add(&(P->x),&(P->x),&(P->x));	//x.add(x);       //(y^2-9bz^2)xy2
+    FP8_YYY_norm(&t0);			//x.norm();
+    FP8_YYY_mul(&(P->x),&t0,&t1);	//x.mul(t1);
+    FP8_YYY_add(&(P->x),&(P->x),&(P->x));	//x.add(x);       //(y^2-9bz^2)xy2
 
-	FP8_YYY_norm(&(P->x));			//x.norm(); 
+    FP8_YYY_norm(&(P->x));			//x.norm();
 
-	FP8_YYY_norm(&(P->y));			//y.norm();
+    FP8_YYY_norm(&(P->y));			//y.norm();
 
     return 1;
 }
@@ -434,88 +434,88 @@
 int ECP8_ZZZ_add(ECP8_ZZZ *P,ECP8_ZZZ *Q)
 {
     FP8_YYY t0,t1,t2,t3,t4,x3,y3,z3;
-	int b3=3*CURVE_B_I_ZZZ;
+    int b3=3*CURVE_B_I_ZZZ;
 
-	FP8_YYY_mul(&t0,&(P->x),&(Q->x));	//t0.mul(Q.x);         // x.Q.x
-	FP8_YYY_mul(&t1,&(P->y),&(Q->y));	//t1.mul(Q.y);		 // y.Q.y
+    FP8_YYY_mul(&t0,&(P->x),&(Q->x));	//t0.mul(Q.x);         // x.Q.x
+    FP8_YYY_mul(&t1,&(P->y),&(Q->y));	//t1.mul(Q.y);		 // y.Q.y
 
-	FP8_YYY_mul(&t2,&(P->z),&(Q->z));	//t2.mul(Q.z);
-	FP8_YYY_add(&t3,&(P->x),&(P->y));	//t3.add(y); 
-	FP8_YYY_norm(&t3);				//t3.norm();          //t3=X1+Y1         
-	FP8_YYY_add(&t4,&(Q->x),&(Q->y));	//t4.add(Q.y); 
-	FP8_YYY_norm(&t4);				//t4.norm();			//t4=X2+Y2
-	FP8_YYY_mul(&t3,&t3,&t4);		//t3.mul(t4);						//t3=(X1+Y1)(X2+Y2)
-	FP8_YYY_add(&t4,&t0,&t1);		//t4.add(t1);		//t4=X1.X2+Y1.Y2
+    FP8_YYY_mul(&t2,&(P->z),&(Q->z));	//t2.mul(Q.z);
+    FP8_YYY_add(&t3,&(P->x),&(P->y));	//t3.add(y);
+    FP8_YYY_norm(&t3);				//t3.norm();          //t3=X1+Y1
+    FP8_YYY_add(&t4,&(Q->x),&(Q->y));	//t4.add(Q.y);
+    FP8_YYY_norm(&t4);				//t4.norm();			//t4=X2+Y2
+    FP8_YYY_mul(&t3,&t3,&t4);		//t3.mul(t4);						//t3=(X1+Y1)(X2+Y2)
+    FP8_YYY_add(&t4,&t0,&t1);		//t4.add(t1);		//t4=X1.X2+Y1.Y2
 
-	FP8_YYY_sub(&t3,&t3,&t4);		//t3.sub(t4); 
-	FP8_YYY_norm(&t3);				//t3.norm(); 
+    FP8_YYY_sub(&t3,&t3,&t4);		//t3.sub(t4);
+    FP8_YYY_norm(&t3);				//t3.norm();
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP8_YYY_times_i(&t3);			//t3.mul_ip();  //t3=(X1+Y1)(X2+Y2)-(X1.X2+Y1.Y2) = X1.Y2+X2.Y1     
-#endif
-                   
-	FP8_YYY_add(&t4,&(P->y),&(P->z));	//t4.add(z); 
-	FP8_YYY_norm(&t4);				//t4.norm();			//t4=Y1+Z1
-
-	FP8_YYY_add(&x3,&(Q->y),&(Q->z));	//x3.add(Q.z); 
-	FP8_YYY_norm(&x3);				//x3.norm();			//x3=Y2+Z2
-
-	FP8_YYY_mul(&t4,&t4,&x3);		//t4.mul(x3);						//t4=(Y1+Z1)(Y2+Z2)
-
-	FP8_YYY_add(&x3,&t1,&t2);		//x3.add(t2);						//X3=Y1.Y2+Z1.Z2
-	
-	FP8_YYY_sub(&t4,&t4,&x3);		//t4.sub(x3); 
-	FP8_YYY_norm(&t4);				//t4.norm(); 
-#if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP8_YYY_times_i(&t4);			//t4.mul_ip(); //t4=(Y1+Z1)(Y2+Z2) - (Y1.Y2+Z1.Z2) = Y1.Z2+Y2.Z1     
+    FP8_YYY_times_i(&t3);			//t3.mul_ip();  //t3=(X1+Y1)(X2+Y2)-(X1.X2+Y1.Y2) = X1.Y2+X2.Y1
 #endif
 
-	FP8_YYY_add(&x3,&(P->x),&(P->z));	//x3.add(z); 
-	FP8_YYY_norm(&x3);				//x3.norm();	// x3=X1+Z1
-		
-	FP8_YYY_add(&y3,&(Q->x),&(Q->z));	//y3.add(Q.z); 
-	FP8_YYY_norm(&y3);				//y3.norm();				// y3=X2+Z2
-	FP8_YYY_mul(&x3,&x3,&y3);		//x3.mul(y3);							// x3=(X1+Z1)(X2+Z2)
+    FP8_YYY_add(&t4,&(P->y),&(P->z));	//t4.add(z);
+    FP8_YYY_norm(&t4);				//t4.norm();			//t4=Y1+Z1
 
-	FP8_YYY_add(&y3,&t0,&t2);		//y3.add(t2);							// y3=X1.X2+Z1+Z2
-	FP8_YYY_sub(&y3,&x3,&y3);		//y3.rsub(x3); 
-	FP8_YYY_norm(&y3);				//y3.norm();				// y3=(X1+Z1)(X2+Z2) - (X1.X2+Z1.Z2) = X1.Z2+X2.Z1
+    FP8_YYY_add(&x3,&(Q->y),&(Q->z));	//x3.add(Q.z);
+    FP8_YYY_norm(&x3);				//x3.norm();			//x3=Y2+Z2
+
+    FP8_YYY_mul(&t4,&t4,&x3);		//t4.mul(x3);						//t4=(Y1+Z1)(Y2+Z2)
+
+    FP8_YYY_add(&x3,&t1,&t2);		//x3.add(t2);						//X3=Y1.Y2+Z1.Z2
+
+    FP8_YYY_sub(&t4,&t4,&x3);		//t4.sub(x3);
+    FP8_YYY_norm(&t4);				//t4.norm();
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-	FP8_YYY_times_i(&t0);			//t0.mul_ip(); 
-	FP8_YYY_times_i(&t1);			//t1.mul_ip(); 
+    FP8_YYY_times_i(&t4);			//t4.mul_ip(); //t4=(Y1+Z1)(Y2+Z2) - (Y1.Y2+Z1.Z2) = Y1.Z2+Y2.Z1
 #endif
 
-	FP8_YYY_add(&x3,&t0,&t0);		//x3.add(t0); 
-	FP8_YYY_add(&t0,&t0,&x3);		//t0.add(x3); 
-	FP8_YYY_norm(&t0);				//t0.norm();
-	FP8_YYY_imul(&t2,&t2,b3);		//t2.imul(b); 	
+    FP8_YYY_add(&x3,&(P->x),&(P->z));	//x3.add(z);
+    FP8_YYY_norm(&x3);				//x3.norm();	// x3=X1+Z1
+
+    FP8_YYY_add(&y3,&(Q->x),&(Q->z));	//y3.add(Q.z);
+    FP8_YYY_norm(&y3);				//y3.norm();				// y3=X2+Z2
+    FP8_YYY_mul(&x3,&x3,&y3);		//x3.mul(y3);							// x3=(X1+Z1)(X2+Z2)
+
+    FP8_YYY_add(&y3,&t0,&t2);		//y3.add(t2);							// y3=X1.X2+Z1+Z2
+    FP8_YYY_sub(&y3,&x3,&y3);		//y3.rsub(x3);
+    FP8_YYY_norm(&y3);				//y3.norm();				// y3=(X1+Z1)(X2+Z2) - (X1.X2+Z1.Z2) = X1.Z2+X2.Z1
+#if SEXTIC_TWIST_ZZZ==D_TYPE
+    FP8_YYY_times_i(&t0);			//t0.mul_ip();
+    FP8_YYY_times_i(&t1);			//t1.mul_ip();
+#endif
+
+    FP8_YYY_add(&x3,&t0,&t0);		//x3.add(t0);
+    FP8_YYY_add(&t0,&t0,&x3);		//t0.add(x3);
+    FP8_YYY_norm(&t0);				//t0.norm();
+    FP8_YYY_imul(&t2,&t2,b3);		//t2.imul(b);
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-	FP8_YYY_times_i(&t2);
+    FP8_YYY_times_i(&t2);
 #endif
 
-	FP8_YYY_add(&z3,&t1,&t2);		//z3.add(t2); 
-	FP8_YYY_norm(&z3);				//z3.norm();
-	FP8_YYY_sub(&t1,&t1,&t2);		//t1.sub(t2); 
-	FP8_YYY_norm(&t1);				//t1.norm(); 
-	FP8_YYY_imul(&y3,&y3,b3);		//y3.imul(b); 
+    FP8_YYY_add(&z3,&t1,&t2);		//z3.add(t2);
+    FP8_YYY_norm(&z3);				//z3.norm();
+    FP8_YYY_sub(&t1,&t1,&t2);		//t1.sub(t2);
+    FP8_YYY_norm(&t1);				//t1.norm();
+    FP8_YYY_imul(&y3,&y3,b3);		//y3.imul(b);
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-	FP8_YYY_times_i(&y3);
+    FP8_YYY_times_i(&y3);
 #endif
 
-	FP8_YYY_mul(&x3,&y3,&t4);		//x3.mul(t4); 
+    FP8_YYY_mul(&x3,&y3,&t4);		//x3.mul(t4);
 
-	FP8_YYY_mul(&t2,&t3,&t1);		//t2.mul(t1); 
-	FP8_YYY_sub(&(P->x),&t2,&x3);		//x3.rsub(t2);
-	FP8_YYY_mul(&y3,&y3,&t0);		//y3.mul(t0); 
-	FP8_YYY_mul(&t1,&t1,&z3);		//t1.mul(z3); 
-	FP8_YYY_add(&(P->y),&y3,&t1);		//y3.add(t1);
-	FP8_YYY_mul(&t0,&t0,&t3);		//t0.mul(t3); 
-	FP8_YYY_mul(&z3,&z3,&t4);		//z3.mul(t4); 
-	FP8_YYY_add(&(P->z),&z3,&t0);		//z3.add(t0);
+    FP8_YYY_mul(&t2,&t3,&t1);		//t2.mul(t1);
+    FP8_YYY_sub(&(P->x),&t2,&x3);		//x3.rsub(t2);
+    FP8_YYY_mul(&y3,&y3,&t0);		//y3.mul(t0);
+    FP8_YYY_mul(&t1,&t1,&z3);		//t1.mul(z3);
+    FP8_YYY_add(&(P->y),&y3,&t1);		//y3.add(t1);
+    FP8_YYY_mul(&t0,&t0,&t3);		//t0.mul(t3);
+    FP8_YYY_mul(&z3,&z3,&t4);		//z3.mul(t4);
+    FP8_YYY_add(&(P->z),&z3,&t0);		//z3.add(t0);
 
 
-	FP8_YYY_norm(&(P->x));			//x.norm(); 
-	FP8_YYY_norm(&(P->y));			//y.norm();
-	FP8_YYY_norm(&(P->z));			//z.norm();
+    FP8_YYY_norm(&(P->x));			//x.norm();
+    FP8_YYY_norm(&(P->y));			//y.norm();
+    FP8_YYY_norm(&(P->z));			//z.norm();
 
     return 0;
 }
@@ -524,18 +524,18 @@
 /* SU= 16 */
 void ECP8_ZZZ_sub(ECP8_ZZZ *P,ECP8_ZZZ *Q)
 {
-	ECP8_ZZZ NQ;
-	ECP8_ZZZ_copy(&NQ,Q);
-	ECP8_ZZZ_neg(&NQ);
+    ECP8_ZZZ NQ;
+    ECP8_ZZZ_copy(&NQ,Q);
+    ECP8_ZZZ_neg(&NQ);
     ECP8_ZZZ_add(P,&NQ);
 }
 
 
 void ECP8_ZZZ_reduce(ECP8_ZZZ *P)
 {
-	FP8_YYY_reduce(&(P->x));
-	FP8_YYY_reduce(&(P->y));
-	FP8_YYY_reduce(&(P->z));
+    FP8_YYY_reduce(&(P->x));
+    FP8_YYY_reduce(&(P->y));
+    FP8_YYY_reduce(&(P->z));
 }
 
 /* P*=e */
@@ -549,7 +549,7 @@
     sign8 w[1+(NLEN_XXX*BASEBITS_XXX+3)/4];
 
     if (ECP8_ZZZ_isinf(P)) return;
-    
+
     /* precompute table */
 
     ECP8_ZZZ_copy(&Q,P);
@@ -598,80 +598,82 @@
         ECP8_ZZZ_add(P,&Q);
     }
     ECP8_ZZZ_sub(P,&C); /* apply correction */
-	ECP8_ZZZ_affine(P);
+    ECP8_ZZZ_affine(P);
 }
 
 void ECP8_ZZZ_frob_constants(FP2_YYY F[3])
 {
     FP_YYY fx,fy;
-	FP2_YYY X;
+    FP2_YYY X;
 
     FP_YYY_rcopy(&fx,Fra_YYY);
     FP_YYY_rcopy(&fy,Frb_YYY);
     FP2_YYY_from_FPs(&X,&fx,&fy);
 
 
-	FP2_YYY_sqr(&F[0],&X);			// FF=F^2=(1+i)^(p-19)/12
-	FP2_YYY_copy(&F[2],&F[0]);
-	FP2_YYY_mul_ip(&F[2]);			// W=(1+i)^12/12.(1+i)^(p-19)/12 = (1+i)^(p-7)/12
-	FP2_YYY_norm(&F[2]);
-	FP2_YYY_sqr(&F[1],&F[2]);
-	FP2_YYY_mul(&F[2],&F[2],&F[1]);	// W=(1+i)^(p-7)/4
+    FP2_YYY_sqr(&F[0],&X);			// FF=F^2=(1+i)^(p-19)/12
+    FP2_YYY_copy(&F[2],&F[0]);
+    FP2_YYY_mul_ip(&F[2]);			// W=(1+i)^12/12.(1+i)^(p-19)/12 = (1+i)^(p-7)/12
+    FP2_YYY_norm(&F[2]);
+    FP2_YYY_sqr(&F[1],&F[2]);
+    FP2_YYY_mul(&F[2],&F[2],&F[1]);	// W=(1+i)^(p-7)/4
 
-	FP2_YYY_mul_ip(&F[2]);			// W=(1+i)^4/4.W=(1+i)^(p-7)/4 = (1+i)^(p-3)/4
-	FP2_YYY_norm(&F[2]);
+    FP2_YYY_mul_ip(&F[2]);			// W=(1+i)^4/4.W=(1+i)^(p-7)/4 = (1+i)^(p-3)/4
+    FP2_YYY_norm(&F[2]);
 
-	FP2_YYY_copy(&F[1],&X);
+    FP2_YYY_copy(&F[1],&X);
 
-#if SEXTIC_TWIST_ZZZ == M_TYPE	
-	FP2_YYY_mul_ip(&F[1]);		// (1+i)^24/24.(1+i)^(p-19)/24 = (1+i)^(p+5)/24
-	FP2_YYY_inv(&F[1],&F[1]);		// (1+i)^-(p+5)/24
-	FP2_YYY_sqr(&F[0],&F[1]);		// (1+i)^-(p+5)/12
+#if SEXTIC_TWIST_ZZZ == M_TYPE
+    FP2_YYY_mul_ip(&F[1]);		// (1+i)^24/24.(1+i)^(p-19)/24 = (1+i)^(p+5)/24
+    FP2_YYY_inv(&F[1],&F[1]);		// (1+i)^-(p+5)/24
+    FP2_YYY_sqr(&F[0],&F[1]);		// (1+i)^-(p+5)/12
 #endif
 
 
-	FP2_YYY_mul_ip(&F[0]);		// FF=(1+i)^(p-19)/12.(1+i)^12/12 = (1+i)^(p-7)/12					// FF=(1+i)^12/12.(1+i)^-(p+5)/12 = (1+i)^-(p-7)/12
-	FP2_YYY_norm(&F[0]);
+    FP2_YYY_mul_ip(&F[0]);		// FF=(1+i)^(p-19)/12.(1+i)^12/12 = (1+i)^(p-7)/12					// FF=(1+i)^12/12.(1+i)^-(p+5)/12 = (1+i)^-(p-7)/12
+    FP2_YYY_norm(&F[0]);
 
-	FP2_YYY_mul(&F[1],&F[1],&F[0]);  // (1+i)^(p-7)/12 . (1+i)^(p-19)/24 = (1+i)^(p-11)/8				// (1+i)^-(p-7)/12 . (1+i)^-(p+5)/24 = (1+i)^-(p-3)/8
+    FP2_YYY_mul(&F[1],&F[1],&F[0]);  // (1+i)^(p-7)/12 . (1+i)^(p-19)/24 = (1+i)^(p-11)/8				// (1+i)^-(p-7)/12 . (1+i)^-(p+5)/24 = (1+i)^-(p-3)/8
 
 }
 
 /* Calculates q^n.P using Frobenius constant X */
 void ECP8_ZZZ_frob(ECP8_ZZZ *P,FP2_YYY F[3],int n)
 {
-	int i;
-	FP8_YYY X,Y,Z;
+    int i;
+    FP8_YYY X,Y,Z;
 
-	FP8_YYY_copy(&X,&(P->x));
-	FP8_YYY_copy(&Y,&(P->y));
-	FP8_YYY_copy(&Z,&(P->z));
+    FP8_YYY_copy(&X,&(P->x));
+    FP8_YYY_copy(&Y,&(P->y));
+    FP8_YYY_copy(&Z,&(P->z));
 
-	for (i=0;i<n;i++)
-	{
-		FP8_YYY_frob(&X,&F[2]);		// X^p		
-		FP8_YYY_qmul(&X,&X,&F[0]); 
-#if SEXTIC_TWIST_ZZZ == M_TYPE			
-		FP8_YYY_div_i2(&X);			// X^p.(1+i)^-(p-1)/12
-#endif
-#if SEXTIC_TWIST_ZZZ == D_TYPE			
-		FP8_YYY_times_i2(&X);		// X^p.(1+i)^(p-1)/12
-#endif
-
-		FP8_YYY_frob(&Y,&F[2]);		// Y^p
-		FP8_YYY_qmul(&Y,&Y,&F[1]); 
-#if SEXTIC_TWIST_ZZZ == M_TYPE		
-		FP8_YYY_div_i(&Y);			// Y^p.(1+i)^-(p-1)/8
+    for (i=0; i<n; i++)
+    {
+        FP8_YYY_frob(&X,&F[2]);		// X^p
+        FP8_YYY_qmul(&X,&X,&F[0]);
+#if SEXTIC_TWIST_ZZZ == M_TYPE
+        FP8_YYY_div_i2(&X);			// X^p.(1+i)^-(p-1)/12
 #endif
 #if SEXTIC_TWIST_ZZZ == D_TYPE
-		FP8_YYY_times_i2(&Y); FP8_YYY_times_i2(&Y); FP8_YYY_times_i(&Y);  // Y^p.(1+i)^(p-1)/8
+        FP8_YYY_times_i2(&X);		// X^p.(1+i)^(p-1)/12
 #endif
-		FP8_YYY_frob(&Z,&F[2]);
-	}
 
-	FP8_YYY_copy(&(P->x),&X);
-	FP8_YYY_copy(&(P->y),&Y);
-	FP8_YYY_copy(&(P->z),&Z);
+        FP8_YYY_frob(&Y,&F[2]);		// Y^p
+        FP8_YYY_qmul(&Y,&Y,&F[1]);
+#if SEXTIC_TWIST_ZZZ == M_TYPE
+        FP8_YYY_div_i(&Y);			// Y^p.(1+i)^-(p-1)/8
+#endif
+#if SEXTIC_TWIST_ZZZ == D_TYPE
+        FP8_YYY_times_i2(&Y);
+        FP8_YYY_times_i2(&Y);
+        FP8_YYY_times_i(&Y);  // Y^p.(1+i)^(p-1)/8
+#endif
+        FP8_YYY_frob(&Z,&F[2]);
+    }
+
+    FP8_YYY_copy(&(P->x),&X);
+    FP8_YYY_copy(&(P->y),&Y);
+    FP8_YYY_copy(&(P->z),&Z);
 }
 
 /* Side channel attack secure */
@@ -681,71 +683,71 @@
 void ECP8_ZZZ_mul16(ECP8_ZZZ *P,ECP8_ZZZ Q[16],BIG_XXX u[16])
 {
     int i,j,k,nb,pb1,pb2,pb3,pb4,bt;
-	ECP8_ZZZ T1[8],T2[8],T3[8],T4[8],W;
+    ECP8_ZZZ T1[8],T2[8],T3[8],T4[8],W;
     BIG_XXX mt,t[16];
     sign8 w1[NLEN_XXX*BASEBITS_XXX+1];
     sign8 s1[NLEN_XXX*BASEBITS_XXX+1];
     sign8 w2[NLEN_XXX*BASEBITS_XXX+1];
-    sign8 s2[NLEN_XXX*BASEBITS_XXX+1];	
+    sign8 s2[NLEN_XXX*BASEBITS_XXX+1];
     sign8 w3[NLEN_XXX*BASEBITS_XXX+1];
     sign8 s3[NLEN_XXX*BASEBITS_XXX+1];
     sign8 w4[NLEN_XXX*BASEBITS_XXX+1];
-    sign8 s4[NLEN_XXX*BASEBITS_XXX+1];	
+    sign8 s4[NLEN_XXX*BASEBITS_XXX+1];
 
-	FP2_YYY X[3];
-	ECP8_ZZZ_frob_constants(X);
+    FP2_YYY X[3];
+    ECP8_ZZZ_frob_constants(X);
 
     for (i=0; i<16; i++)
-	{
+    {
         BIG_XXX_copy(t[i],u[i]);
-	}
+    }
 // Precomputed table
     ECP8_ZZZ_copy(&T1[0],&Q[0]); // Q[0]
     ECP8_ZZZ_copy(&T1[1],&T1[0]);
-	ECP8_ZZZ_add(&T1[1],&Q[1]);	// Q[0]+Q[1]
+    ECP8_ZZZ_add(&T1[1],&Q[1]);	// Q[0]+Q[1]
     ECP8_ZZZ_copy(&T1[2],&T1[0]);
-	ECP8_ZZZ_add(&T1[2],&Q[2]);	// Q[0]+Q[2]
-	ECP8_ZZZ_copy(&T1[3],&T1[1]);
-	ECP8_ZZZ_add(&T1[3],&Q[2]);	// Q[0]+Q[1]+Q[2]
-	ECP8_ZZZ_copy(&T1[4],&T1[0]);
-	ECP8_ZZZ_add(&T1[4],&Q[3]);  // Q[0]+Q[3]
-	ECP8_ZZZ_copy(&T1[5],&T1[1]);
-	ECP8_ZZZ_add(&T1[5],&Q[3]);	// Q[0]+Q[1]+Q[3]
-	ECP8_ZZZ_copy(&T1[6],&T1[2]);
-	ECP8_ZZZ_add(&T1[6],&Q[3]);	// Q[0]+Q[2]+Q[3]
-	ECP8_ZZZ_copy(&T1[7],&T1[3]);
-	ECP8_ZZZ_add(&T1[7],&Q[3]);	// Q[0]+Q[1]+Q[2]+Q[3]
+    ECP8_ZZZ_add(&T1[2],&Q[2]);	// Q[0]+Q[2]
+    ECP8_ZZZ_copy(&T1[3],&T1[1]);
+    ECP8_ZZZ_add(&T1[3],&Q[2]);	// Q[0]+Q[1]+Q[2]
+    ECP8_ZZZ_copy(&T1[4],&T1[0]);
+    ECP8_ZZZ_add(&T1[4],&Q[3]);  // Q[0]+Q[3]
+    ECP8_ZZZ_copy(&T1[5],&T1[1]);
+    ECP8_ZZZ_add(&T1[5],&Q[3]);	// Q[0]+Q[1]+Q[3]
+    ECP8_ZZZ_copy(&T1[6],&T1[2]);
+    ECP8_ZZZ_add(&T1[6],&Q[3]);	// Q[0]+Q[2]+Q[3]
+    ECP8_ZZZ_copy(&T1[7],&T1[3]);
+    ECP8_ZZZ_add(&T1[7],&Q[3]);	// Q[0]+Q[1]+Q[2]+Q[3]
 
-//  Use Frobenius 
+//  Use Frobenius
 
-	for (i=0;i<8;i++)
-	{
-		ECP8_ZZZ_copy(&T2[i],&T1[i]);
-		ECP8_ZZZ_frob(&T2[i],X,4);
+    for (i=0; i<8; i++)
+    {
+        ECP8_ZZZ_copy(&T2[i],&T1[i]);
+        ECP8_ZZZ_frob(&T2[i],X,4);
 
-		ECP8_ZZZ_copy(&T3[i],&T2[i]);
-		ECP8_ZZZ_frob(&T3[i],X,4);
+        ECP8_ZZZ_copy(&T3[i],&T2[i]);
+        ECP8_ZZZ_frob(&T3[i],X,4);
 
-		ECP8_ZZZ_copy(&T4[i],&T3[i]);
-		ECP8_ZZZ_frob(&T4[i],X,4);
-	}
+        ECP8_ZZZ_copy(&T4[i],&T3[i]);
+        ECP8_ZZZ_frob(&T4[i],X,4);
+    }
 
 // Make them odd
-	pb1=1-BIG_XXX_parity(t[0]);
-	BIG_XXX_inc(t[0],pb1);
-	BIG_XXX_norm(t[0]);
+    pb1=1-BIG_XXX_parity(t[0]);
+    BIG_XXX_inc(t[0],pb1);
+    BIG_XXX_norm(t[0]);
 
-	pb2=1-BIG_XXX_parity(t[4]);
-	BIG_XXX_inc(t[4],pb2);
-	BIG_XXX_norm(t[4]);
+    pb2=1-BIG_XXX_parity(t[4]);
+    BIG_XXX_inc(t[4],pb2);
+    BIG_XXX_norm(t[4]);
 
-	pb3=1-BIG_XXX_parity(t[8]);
-	BIG_XXX_inc(t[8],pb3);
-	BIG_XXX_norm(t[8]);
+    pb3=1-BIG_XXX_parity(t[8]);
+    BIG_XXX_inc(t[8],pb3);
+    BIG_XXX_norm(t[8]);
 
-	pb4=1-BIG_XXX_parity(t[12]);
-	BIG_XXX_inc(t[12],pb4);
-	BIG_XXX_norm(t[12]);
+    pb4=1-BIG_XXX_parity(t[12]);
+    BIG_XXX_inc(t[12],pb4);
+    BIG_XXX_norm(t[12]);
 
 // Number of bits
     BIG_XXX_zero(mt);
@@ -755,88 +757,88 @@
     }
     nb=1+BIG_XXX_nbits(mt);
 
-// Sign pivot 
-	s1[nb-1]=1;
-	s2[nb-1]=1;
-	s3[nb-1]=1;
-	s4[nb-1]=1;
-	for (i=0;i<nb-1;i++)
-	{
+// Sign pivot
+    s1[nb-1]=1;
+    s2[nb-1]=1;
+    s3[nb-1]=1;
+    s4[nb-1]=1;
+    for (i=0; i<nb-1; i++)
+    {
         BIG_XXX_fshr(t[0],1);
-		s1[i]=2*BIG_XXX_parity(t[0])-1;
+        s1[i]=2*BIG_XXX_parity(t[0])-1;
         BIG_XXX_fshr(t[4],1);
-		s2[i]=2*BIG_XXX_parity(t[4])-1;
+        s2[i]=2*BIG_XXX_parity(t[4])-1;
         BIG_XXX_fshr(t[8],1);
-		s3[i]=2*BIG_XXX_parity(t[8])-1;
+        s3[i]=2*BIG_XXX_parity(t[8])-1;
         BIG_XXX_fshr(t[12],1);
-		s4[i]=2*BIG_XXX_parity(t[12])-1;
-	}
+        s4[i]=2*BIG_XXX_parity(t[12])-1;
+    }
 
 
 // Recoded exponents
     for (i=0; i<nb; i++)
     {
-		w1[i]=0;
-		k=1;
-		for (j=1; j<4; j++)
-		{
-			bt=s1[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w1[i]=0;
+        k=1;
+        for (j=1; j<4; j++)
+        {
+            bt=s1[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w1[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w1[i]+=bt*k;
+            k*=2;
         }
 
-		w2[i]=0;
-		k=1;
-		for (j=5; j<8; j++)
-		{
-			bt=s2[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w2[i]=0;
+        k=1;
+        for (j=5; j<8; j++)
+        {
+            bt=s2[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w2[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w2[i]+=bt*k;
+            k*=2;
         }
 
-		w3[i]=0;
-		k=1;
-		for (j=9; j<12; j++)
-		{
-			bt=s3[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w3[i]=0;
+        k=1;
+        for (j=9; j<12; j++)
+        {
+            bt=s3[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w3[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w3[i]+=bt*k;
+            k*=2;
         }
 
-		w4[i]=0;
-		k=1;
-		for (j=13; j<16; j++)
-		{
-			bt=s4[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w4[i]=0;
+        k=1;
+        for (j=13; j<16; j++)
+        {
+            bt=s4[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w4[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w4[i]+=bt*k;
+            k*=2;
         }
-    }	
+    }
 
 // Main loop
-	ECP8_ZZZ_select(P,T1,2*w1[nb-1]+1);
-	ECP8_ZZZ_select(&W,T2,2*w2[nb-1]+1);
-	ECP8_ZZZ_add(P,&W);
-	ECP8_ZZZ_select(&W,T3,2*w3[nb-1]+1);
-	ECP8_ZZZ_add(P,&W);
-	ECP8_ZZZ_select(&W,T4,2*w4[nb-1]+1);
-	ECP8_ZZZ_add(P,&W);
+    ECP8_ZZZ_select(P,T1,2*w1[nb-1]+1);
+    ECP8_ZZZ_select(&W,T2,2*w2[nb-1]+1);
+    ECP8_ZZZ_add(P,&W);
+    ECP8_ZZZ_select(&W,T3,2*w3[nb-1]+1);
+    ECP8_ZZZ_add(P,&W);
+    ECP8_ZZZ_select(&W,T4,2*w4[nb-1]+1);
+    ECP8_ZZZ_add(P,&W);
 
     for (i=nb-2; i>=0; i--)
     {
@@ -852,20 +854,20 @@
     }
 
 // apply corrections
-	ECP8_ZZZ_copy(&W,P);   
-	ECP8_ZZZ_sub(&W,&Q[0]);
-	ECP8_ZZZ_cmove(P,&W,pb1);
-	ECP8_ZZZ_copy(&W,P);   
-	ECP8_ZZZ_sub(&W,&Q[4]);
-	ECP8_ZZZ_cmove(P,&W,pb2);
+    ECP8_ZZZ_copy(&W,P);
+    ECP8_ZZZ_sub(&W,&Q[0]);
+    ECP8_ZZZ_cmove(P,&W,pb1);
+    ECP8_ZZZ_copy(&W,P);
+    ECP8_ZZZ_sub(&W,&Q[4]);
+    ECP8_ZZZ_cmove(P,&W,pb2);
 
-	ECP8_ZZZ_copy(&W,P);   
-	ECP8_ZZZ_sub(&W,&Q[8]);
-	ECP8_ZZZ_cmove(P,&W,pb3);
-	ECP8_ZZZ_copy(&W,P);   
-	ECP8_ZZZ_sub(&W,&Q[12]);
-	ECP8_ZZZ_cmove(P,&W,pb4);
-	ECP8_ZZZ_affine(P);
+    ECP8_ZZZ_copy(&W,P);
+    ECP8_ZZZ_sub(&W,&Q[8]);
+    ECP8_ZZZ_cmove(P,&W,pb3);
+    ECP8_ZZZ_copy(&W,P);
+    ECP8_ZZZ_sub(&W,&Q[12]);
+    ECP8_ZZZ_cmove(P,&W,pb4);
+    ECP8_ZZZ_affine(P);
 }
 
 /* Map to hash value to point on G2 from random BIG_XXX */
@@ -873,14 +875,13 @@
 void ECP8_ZZZ_mapit(ECP8_ZZZ *Q,octet *W)
 {
     BIG_XXX q,one,x,hv;
-	FP_YYY Fx,Fy;
     FP2_YYY T,X[3];
-	FP4_YYY X4;
-	FP8_YYY X8;
+    FP4_YYY X4;
+    FP8_YYY X8;
 
-    ECP8_ZZZ xQ, x2Q, x3Q, x4Q , x5Q, x6Q, x7Q, x8Q;
+    ECP8_ZZZ xQ, x2Q, x3Q, x4Q, x5Q, x6Q, x7Q, x8Q;
 
-	BIG_XXX_fromBytes(hv,W->val);
+    BIG_XXX_fromBytes(hv,W->val);
     BIG_XXX_rcopy(q,Modulus_YYY);
     BIG_XXX_one(one);
     BIG_XXX_mod(hv,q);
@@ -888,83 +889,83 @@
     for (;;)
     {
         FP2_YYY_from_BIGs(&T,one,hv);  /*******/
-		FP4_YYY_from_FP2(&X4,&T);
-		FP8_YYY_from_FP4(&X8,&X4);
+        FP4_YYY_from_FP2(&X4,&T);
+        FP8_YYY_from_FP4(&X8,&X4);
         if (ECP8_ZZZ_setx(Q,&X8)) break;
         BIG_XXX_inc(hv,1);
     }
 
-	ECP8_ZZZ_frob_constants(X);
+    ECP8_ZZZ_frob_constants(X);
 
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
 
-    // Efficient hash maps to G2 on BLS48 curves - Budroni, Pintore 
-	// Q -> x8Q -x7Q -Q +  F(x7Q-x6Q) + F(F(x6Q-x5Q)) +F(F(F(x5Q-x4Q))) +F(F(F(F(x4Q-x3Q)))) + F(F(F(F(F(x3Q-x2Q))))) + F(F(F(F(F(F(x2Q-xQ)))))) + F(F(F(F(F(F(F(xQ-Q))))))) +F(F(F(F(F(F(F(F(2Q))))))))
+    // Efficient hash maps to G2 on BLS48 curves - Budroni, Pintore
+    // Q -> x8Q -x7Q -Q +  F(x7Q-x6Q) + F(F(x6Q-x5Q)) +F(F(F(x5Q-x4Q))) +F(F(F(F(x4Q-x3Q)))) + F(F(F(F(F(x3Q-x2Q))))) + F(F(F(F(F(F(x2Q-xQ)))))) + F(F(F(F(F(F(F(xQ-Q))))))) +F(F(F(F(F(F(F(F(2Q))))))))
 
-	ECP8_ZZZ_copy(&xQ,Q);
-	ECP8_ZZZ_mul(&xQ,x);
-	ECP8_ZZZ_copy(&x2Q,&xQ);
-	ECP8_ZZZ_mul(&x2Q,x);
-	ECP8_ZZZ_copy(&x3Q,&x2Q);
-	ECP8_ZZZ_mul(&x3Q,x);
-	ECP8_ZZZ_copy(&x4Q,&x3Q);
+    ECP8_ZZZ_copy(&xQ,Q);
+    ECP8_ZZZ_mul(&xQ,x);
+    ECP8_ZZZ_copy(&x2Q,&xQ);
+    ECP8_ZZZ_mul(&x2Q,x);
+    ECP8_ZZZ_copy(&x3Q,&x2Q);
+    ECP8_ZZZ_mul(&x3Q,x);
+    ECP8_ZZZ_copy(&x4Q,&x3Q);
 
-	ECP8_ZZZ_mul(&x4Q,x);
-	ECP8_ZZZ_copy(&x5Q,&x4Q);
-	ECP8_ZZZ_mul(&x5Q,x);
-	ECP8_ZZZ_copy(&x6Q,&x5Q);
-	ECP8_ZZZ_mul(&x6Q,x);
-	ECP8_ZZZ_copy(&x7Q,&x6Q);
-	ECP8_ZZZ_mul(&x7Q,x);
-	ECP8_ZZZ_copy(&x8Q,&x7Q);
-	ECP8_ZZZ_mul(&x8Q,x);
+    ECP8_ZZZ_mul(&x4Q,x);
+    ECP8_ZZZ_copy(&x5Q,&x4Q);
+    ECP8_ZZZ_mul(&x5Q,x);
+    ECP8_ZZZ_copy(&x6Q,&x5Q);
+    ECP8_ZZZ_mul(&x6Q,x);
+    ECP8_ZZZ_copy(&x7Q,&x6Q);
+    ECP8_ZZZ_mul(&x7Q,x);
+    ECP8_ZZZ_copy(&x8Q,&x7Q);
+    ECP8_ZZZ_mul(&x8Q,x);
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	ECP8_ZZZ_neg(&xQ);
-	ECP8_ZZZ_neg(&x3Q);
-	ECP8_ZZZ_neg(&x5Q);
-	ECP8_ZZZ_neg(&x7Q);
+    ECP8_ZZZ_neg(&xQ);
+    ECP8_ZZZ_neg(&x3Q);
+    ECP8_ZZZ_neg(&x5Q);
+    ECP8_ZZZ_neg(&x7Q);
 #endif
 
-	ECP8_ZZZ_sub(&x8Q,&x7Q);
-	ECP8_ZZZ_sub(&x8Q,Q);
+    ECP8_ZZZ_sub(&x8Q,&x7Q);
+    ECP8_ZZZ_sub(&x8Q,Q);
 
-	ECP8_ZZZ_sub(&x7Q,&x6Q);
-	ECP8_ZZZ_frob(&x7Q,X,1);
+    ECP8_ZZZ_sub(&x7Q,&x6Q);
+    ECP8_ZZZ_frob(&x7Q,X,1);
 
-	ECP8_ZZZ_sub(&x6Q,&x5Q);
-	ECP8_ZZZ_frob(&x6Q,X,2);
-	
-	ECP8_ZZZ_sub(&x5Q,&x4Q);
-	ECP8_ZZZ_frob(&x5Q,X,3);
-	
-	ECP8_ZZZ_sub(&x4Q,&x3Q);
-	ECP8_ZZZ_frob(&x4Q,X,4);
+    ECP8_ZZZ_sub(&x6Q,&x5Q);
+    ECP8_ZZZ_frob(&x6Q,X,2);
 
-	ECP8_ZZZ_sub(&x3Q,&x2Q);
-	ECP8_ZZZ_frob(&x3Q,X,5);
+    ECP8_ZZZ_sub(&x5Q,&x4Q);
+    ECP8_ZZZ_frob(&x5Q,X,3);
 
-	ECP8_ZZZ_sub(&x2Q,&xQ);
-	ECP8_ZZZ_frob(&x2Q,X,6);
+    ECP8_ZZZ_sub(&x4Q,&x3Q);
+    ECP8_ZZZ_frob(&x4Q,X,4);
 
-	ECP8_ZZZ_sub(&xQ,Q);
-	ECP8_ZZZ_frob(&xQ,X,7);
+    ECP8_ZZZ_sub(&x3Q,&x2Q);
+    ECP8_ZZZ_frob(&x3Q,X,5);
 
-	ECP8_ZZZ_dbl(Q);
-	ECP8_ZZZ_frob(Q,X,8);
+    ECP8_ZZZ_sub(&x2Q,&xQ);
+    ECP8_ZZZ_frob(&x2Q,X,6);
+
+    ECP8_ZZZ_sub(&xQ,Q);
+    ECP8_ZZZ_frob(&xQ,X,7);
+
+    ECP8_ZZZ_dbl(Q);
+    ECP8_ZZZ_frob(Q,X,8);
 
 
-	ECP8_ZZZ_add(Q,&x8Q);
-	ECP8_ZZZ_add(Q,&x7Q);
-	ECP8_ZZZ_add(Q,&x6Q);
-	ECP8_ZZZ_add(Q,&x5Q);
+    ECP8_ZZZ_add(Q,&x8Q);
+    ECP8_ZZZ_add(Q,&x7Q);
+    ECP8_ZZZ_add(Q,&x6Q);
+    ECP8_ZZZ_add(Q,&x5Q);
 
-	ECP8_ZZZ_add(Q,&x4Q);
-	ECP8_ZZZ_add(Q,&x3Q);
-	ECP8_ZZZ_add(Q,&x2Q);
-	ECP8_ZZZ_add(Q,&xQ);
+    ECP8_ZZZ_add(Q,&x4Q);
+    ECP8_ZZZ_add(Q,&x3Q);
+    ECP8_ZZZ_add(Q,&x2Q);
+    ECP8_ZZZ_add(Q,&xQ);
 
-	ECP8_ZZZ_affine(Q);
+    ECP8_ZZZ_affine(Q);
 
 }
 
@@ -972,54 +973,54 @@
 
 void ECP8_ZZZ_generator(ECP8_ZZZ *G)
 {
-	BIG_XXX a,b;
-	FP2_YYY Aa,Bb;
-	FP4_YYY A,B;
-	FP8_YYY X,Y;
+    BIG_XXX a,b;
+    FP2_YYY Aa,Bb;
+    FP4_YYY A,B;
+    FP8_YYY X,Y;
 
-	BIG_XXX_rcopy(a,CURVE_Pxaaa_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pxaab_ZZZ);
-	FP2_YYY_from_BIGs(&Aa,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pxaaa_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pxaab_ZZZ);
+    FP2_YYY_from_BIGs(&Aa,a,b);
 
-	BIG_XXX_rcopy(a,CURVE_Pxaba_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pxabb_ZZZ);
-	FP2_YYY_from_BIGs(&Bb,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pxaba_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pxabb_ZZZ);
+    FP2_YYY_from_BIGs(&Bb,a,b);
 
-	FP4_YYY_from_FP2s(&A,&Aa,&Bb);
+    FP4_YYY_from_FP2s(&A,&Aa,&Bb);
 
-	BIG_XXX_rcopy(a,CURVE_Pxbaa_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pxbab_ZZZ);
-	FP2_YYY_from_BIGs(&Aa,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pxbaa_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pxbab_ZZZ);
+    FP2_YYY_from_BIGs(&Aa,a,b);
 
-	BIG_XXX_rcopy(a,CURVE_Pxbba_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pxbbb_ZZZ);
-	FP2_YYY_from_BIGs(&Bb,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pxbba_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pxbbb_ZZZ);
+    FP2_YYY_from_BIGs(&Bb,a,b);
 
-	FP4_YYY_from_FP2s(&B,&Aa,&Bb);
+    FP4_YYY_from_FP2s(&B,&Aa,&Bb);
 
-	FP8_YYY_from_FP4s(&X,&A,&B);
+    FP8_YYY_from_FP4s(&X,&A,&B);
 
-	BIG_XXX_rcopy(a,CURVE_Pyaaa_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pyaab_ZZZ);
-	FP2_YYY_from_BIGs(&Aa,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pyaaa_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pyaab_ZZZ);
+    FP2_YYY_from_BIGs(&Aa,a,b);
 
-	BIG_XXX_rcopy(a,CURVE_Pyaba_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pyabb_ZZZ);
-	FP2_YYY_from_BIGs(&Bb,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pyaba_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pyabb_ZZZ);
+    FP2_YYY_from_BIGs(&Bb,a,b);
 
-	FP4_YYY_from_FP2s(&A,&Aa,&Bb);
+    FP4_YYY_from_FP2s(&A,&Aa,&Bb);
 
-	BIG_XXX_rcopy(a,CURVE_Pybaa_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pybab_ZZZ);
-	FP2_YYY_from_BIGs(&Aa,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pybaa_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pybab_ZZZ);
+    FP2_YYY_from_BIGs(&Aa,a,b);
 
-	BIG_XXX_rcopy(a,CURVE_Pybba_ZZZ);
-	BIG_XXX_rcopy(b,CURVE_Pybbb_ZZZ);
-	FP2_YYY_from_BIGs(&Bb,a,b);
+    BIG_XXX_rcopy(a,CURVE_Pybba_ZZZ);
+    BIG_XXX_rcopy(b,CURVE_Pybbb_ZZZ);
+    FP2_YYY_from_BIGs(&Bb,a,b);
 
-	FP4_YYY_from_FP2s(&B,&Aa,&Bb);
+    FP4_YYY_from_FP2s(&B,&Aa,&Bb);
 
-	FP8_YYY_from_FP4s(&Y,&A,&B);
+    FP8_YYY_from_FP4s(&Y,&A,&B);
 
-	ECP8_ZZZ_set(G,&X,&Y);
+    ECP8_ZZZ_set(G,&X,&Y);
 }
diff --git a/version3/c/ecp8.h b/version3/c/ecp8.h
index 13aff45..2e3a786 100644
--- a/version3/c/ecp8.h
+++ b/version3/c/ecp8.h
@@ -18,7 +18,7 @@
 //    int inf; /**< Infinity Flag */
     FP8_YYY x;   /**< x-coordinate of point */
     FP8_YYY y;   /**< y-coordinate of point */
-	FP8_YYY z;	/**< z-coordinate of point */
+    FP8_YYY z;	/**< z-coordinate of point */
 } ECP8_ZZZ;
 
 
diff --git a/version3/c/ff.h b/version3/c/ff.h
index a50e653..c3be699 100644
--- a/version3/c/ff.h
+++ b/version3/c/ff.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file ff.h
+ * @file ff_WWW.h
  * @author Mike Scott
  * @brief FF Header File
  *
diff --git a/version3/c/fp.c b/version3/c/fp.c
index 02a8521..ec1ab9a 100644
--- a/version3/c/fp.c
+++ b/version3/c/fp.c
@@ -208,7 +208,7 @@
 {
     BIG_XXX m,t;
     BIG_XXX_rcopy(m,Modulus_YYY);
-	BIG_XXX_copy(t,x->g);
+    BIG_XXX_copy(t,x->g);
     BIG_XXX_mod(t,m);
     return BIG_XXX_iszilch(t);
 }
@@ -256,9 +256,9 @@
 
 int FP_YYY_equals(FP_YYY *x,FP_YYY *y)
 {
-	FP_YYY xg,yg;
-	FP_YYY_copy(&xg,x);
-	FP_YYY_copy(&yg,y);
+    FP_YYY xg,yg;
+    FP_YYY_copy(&xg,x);
+    FP_YYY_copy(&yg,y);
     FP_YYY_reduce(&xg);
     FP_YYY_reduce(&yg);
     if (BIG_XXX_comp(xg.g,yg.g)==0) return 1;
@@ -348,12 +348,12 @@
         // don't want to do this - only a problem for Montgomery modulus and larger constants
         BIG_XXX_zero(k);
         BIG_XXX_inc(k,c);
-		BIG_XXX_norm(k);
+        BIG_XXX_norm(k);
         FP_YYY_nres(&f,k);
         FP_YYY_mul(r,a,&f);
     }
 #endif
- 
+
     if (s)
     {
         FP_YYY_neg(r,r);
@@ -427,21 +427,21 @@
 // Note that MAXXES is bounded to be 2-bits less than half a word
 static int quo(BIG_XXX n,BIG_XXX m)
 {
-	int sh;
-	chunk num,den;
-	int hb=CHUNK/2;
-	if (TBITS_YYY<hb)
-	{
-		sh=hb-TBITS_YYY;
-		num=(n[NLEN_XXX-1]<<sh)|(n[NLEN_XXX-2]>>(BASEBITS_XXX-sh));
-		den=(m[NLEN_XXX-1]<<sh)|(m[NLEN_XXX-2]>>(BASEBITS_XXX-sh));
-	}
-	else
-	{
-		num=n[NLEN_XXX-1];
-		den=m[NLEN_XXX-1];
-	}
-	return (int)(num/(den+1));
+    int sh;
+    chunk num,den;
+    int hb=CHUNK/2;
+    if (TBITS_YYY<hb)
+    {
+        sh=hb-TBITS_YYY;
+        num=(n[NLEN_XXX-1]<<sh)|(n[NLEN_XXX-2]>>(BASEBITS_XXX-sh));
+        den=(m[NLEN_XXX-1]<<sh)|(m[NLEN_XXX-2]>>(BASEBITS_XXX-sh));
+    }
+    else
+    {
+        num=n[NLEN_XXX-1];
+        den=m[NLEN_XXX-1];
+    }
+    return (int)(num/(den+1));
 }
 
 /* SU= 48 */
@@ -449,33 +449,33 @@
 void FP_YYY_reduce(FP_YYY *a)
 {
     BIG_XXX m,r;
-	int sr,sb,q;
-	chunk carry;
+    int sr,sb,q;
+    chunk carry;
 
     BIG_XXX_rcopy(m,Modulus_YYY);
 
-	BIG_XXX_norm(a->g);
+    BIG_XXX_norm(a->g);
 
-	if (a->XES>16)
-	{
-		q=quo(a->g,m);
-		carry=BIG_XXX_pmul(r,m,q);
-		r[NLEN_XXX-1]+=(carry<<BASEBITS_XXX); // correction - put any carry out back in again
-		BIG_XXX_sub(a->g,a->g,r);
-		BIG_XXX_norm(a->g);
-		sb=2;
-	}
-	else sb=logb2(a->XES-1);  // sb does not depend on the actual data
+    if (a->XES>16)
+    {
+        q=quo(a->g,m);
+        carry=BIG_XXX_pmul(r,m,q);
+        r[NLEN_XXX-1]+=(carry<<BASEBITS_XXX); // correction - put any carry out back in again
+        BIG_XXX_sub(a->g,a->g,r);
+        BIG_XXX_norm(a->g);
+        sb=2;
+    }
+    else sb=logb2(a->XES-1);  // sb does not depend on the actual data
 
-	BIG_XXX_fshl(m,sb);
+    BIG_XXX_fshl(m,sb);
 
-	while (sb>0)
-	{
+    while (sb>0)
+    {
 // constant time...
-		sr=BIG_XXX_ssn(r,a->g,m);  // optimized combined shift, subtract and norm
-		BIG_XXX_cmove(a->g,r,1-sr);
-		sb--;
-	}
+        sr=BIG_XXX_ssn(r,a->g,m);  // optimized combined shift, subtract and norm
+        BIG_XXX_cmove(a->g,r,1-sr);
+        sb--;
+    }
 
     //BIG_XXX_mod(a->g,m);
     a->XES=1;
@@ -538,134 +538,148 @@
 
 static void FP_YYY_fpow(FP_YYY *r,FP_YYY *x)
 {
-	int i,j,k,bw,w,c,nw,lo,m,n;
-	FP_YYY xp[11],t,key;
-	const int ac[]={1,2,3,6,12,15,30,60,120,240,255};
+    int i,j,k,bw,w,c,nw,lo,m,n;
+    FP_YYY xp[11],t,key;
+    const int ac[]= {1,2,3,6,12,15,30,60,120,240,255};
 // phase 1
-	FP_YYY_copy(&xp[0],x);	// 1 
-	FP_YYY_sqr(&xp[1],x); // 2
-	FP_YYY_mul(&xp[2],&xp[1],x);  //3
-	FP_YYY_sqr(&xp[3],&xp[2]);  // 6 
-	FP_YYY_sqr(&xp[4],&xp[3]); // 12
-	FP_YYY_mul(&xp[5],&xp[4],&xp[2]); // 15
-	FP_YYY_sqr(&xp[6],&xp[5]); // 30
-	FP_YYY_sqr(&xp[7],&xp[6]); // 60
-	FP_YYY_sqr(&xp[8],&xp[7]); // 120
-	FP_YYY_sqr(&xp[9],&xp[8]); // 240
-	FP_YYY_mul(&xp[10],&xp[9],&xp[5]); // 255
+    FP_YYY_copy(&xp[0],x);	// 1
+    FP_YYY_sqr(&xp[1],x); // 2
+    FP_YYY_mul(&xp[2],&xp[1],x);  //3
+    FP_YYY_sqr(&xp[3],&xp[2]);  // 6
+    FP_YYY_sqr(&xp[4],&xp[3]); // 12
+    FP_YYY_mul(&xp[5],&xp[4],&xp[2]); // 15
+    FP_YYY_sqr(&xp[6],&xp[5]); // 30
+    FP_YYY_sqr(&xp[7],&xp[6]); // 60
+    FP_YYY_sqr(&xp[8],&xp[7]); // 120
+    FP_YYY_sqr(&xp[9],&xp[8]); // 240
+    FP_YYY_mul(&xp[10],&xp[9],&xp[5]); // 255
 
-#if MODTYPE_YYY==PSEUDO_MERSENNE 
-	n=MODBITS_YYY;
+#if MODTYPE_YYY==PSEUDO_MERSENNE
+    n=MODBITS_YYY;
 #endif
 #if MODTYPE_YYY==GENERALISED_MERSENNE  // Goldilocks ONLY
-	n=MODBITS_YYY/2;
+    n=MODBITS_YYY/2;
 #endif
 
-	if (MOD8_YYY==5)
+    if (MOD8_YYY==5)
     {
-		n-=3;
-		c=(MConst_YYY+5)/8;
-	} else {
-		n-=2;
-		c=(MConst_YYY+3)/4;
-	}
+        n-=3;
+        c=(MConst_YYY+5)/8;
+    }
+    else
+    {
+        n-=2;
+        c=(MConst_YYY+3)/4;
+    }
 
-	bw=0; w=1; while (w<c) {w*=2; bw+=1;}
-	k=w-c;
+    bw=0;
+    w=1;
+    while (w<c)
+    {
+        w*=2;
+        bw+=1;
+    }
+    k=w-c;
 
-	if (k!=0)
-	{
-		i=10; while (ac[i]>k) i--;
-		FP_YYY_copy(&key,&xp[i]); 
-		k-=ac[i];
-	}
-	while (k!=0)
-	{
-		i--;
-		if (ac[i]>k) continue;
-		FP_YYY_mul(&key,&key,&xp[i]);
-		k-=ac[i]; 
-	}
+    if (k!=0)
+    {
+        i=10;
+        while (ac[i]>k) i--;
+        FP_YYY_copy(&key,&xp[i]);
+        k-=ac[i];
+    }
+    while (k!=0)
+    {
+        i--;
+        if (ac[i]>k) continue;
+        FP_YYY_mul(&key,&key,&xp[i]);
+        k-=ac[i];
+    }
 
-// phase 2 
-	FP_YYY_copy(&xp[1],&xp[2]);
-	FP_YYY_copy(&xp[2],&xp[5]);
-	FP_YYY_copy(&xp[3],&xp[10]);
+// phase 2
+    FP_YYY_copy(&xp[1],&xp[2]);
+    FP_YYY_copy(&xp[2],&xp[5]);
+    FP_YYY_copy(&xp[3],&xp[10]);
 
-	j=3; m=8;
-	nw=n-bw;
-	while (2*m<nw)
-	{
-		FP_YYY_copy(&t,&xp[j++]);
-		for (i=0;i<m;i++)
-			FP_YYY_sqr(&t,&t); 
-		FP_YYY_mul(&xp[j],&xp[j-1],&t); 
-		m*=2;
-	}
+    j=3;
+    m=8;
+    nw=n-bw;
+    while (2*m<nw)
+    {
+        FP_YYY_copy(&t,&xp[j++]);
+        for (i=0; i<m; i++)
+            FP_YYY_sqr(&t,&t);
+        FP_YYY_mul(&xp[j],&xp[j-1],&t);
+        m*=2;
+    }
 
-	lo=nw-m;
-	FP_YYY_copy(r,&xp[j]);
+    lo=nw-m;
+    FP_YYY_copy(r,&xp[j]);
 
-	while (lo!=0)
-	{
-		m/=2; j--;
-		if (lo<m) continue;
-		lo-=m;
-		FP_YYY_copy(&t,r);
-		for (i=0;i<m;i++)
-			FP_YYY_sqr(&t,&t);
-		FP_YYY_mul(r,&t,&xp[j]);
-	}
+    while (lo!=0)
+    {
+        m/=2;
+        j--;
+        if (lo<m) continue;
+        lo-=m;
+        FP_YYY_copy(&t,r);
+        for (i=0; i<m; i++)
+            FP_YYY_sqr(&t,&t);
+        FP_YYY_mul(r,&t,&xp[j]);
+    }
 // phase 3
 
-	if (bw!=0)
-	{
-		for (i=0;i<bw;i++ )
-			FP_YYY_sqr(r,r);
-		FP_YYY_mul(r,r,&key);
-	}
+    if (bw!=0)
+    {
+        for (i=0; i<bw; i++ )
+            FP_YYY_sqr(r,r);
+        FP_YYY_mul(r,r,&key);
+    }
 #if MODTYPE_YYY==GENERALISED_MERSENNE  // Goldilocks ONLY
-	FP_YYY_copy(&key,r);
-	FP_YYY_sqr(&t,&key);
-	FP_YYY_mul(r,&t,x);
-	for (i=0;i<n+1;i++)
-		FP_YYY_sqr(r,r);
-	FP_YYY_mul(r,r,&key);
+    FP_YYY_copy(&key,r);
+    FP_YYY_sqr(&t,&key);
+    FP_YYY_mul(r,&t,x);
+    for (i=0; i<n+1; i++)
+        FP_YYY_sqr(r,r);
+    FP_YYY_mul(r,r,&key);
 #endif
 }
 
 void FP_YYY_inv(FP_YYY *r,FP_YYY *x)
 {
-	FP_YYY y,t;
-	FP_YYY_fpow(&y,x);
+    FP_YYY y,t;
+    FP_YYY_fpow(&y,x);
     if (MOD8_YYY==5)
-    { // r=x^3.y^8
-		FP_YYY_sqr(&t,x);
-		FP_YYY_mul(&t,&t,x);
-		FP_YYY_sqr(&y,&y);
-		FP_YYY_sqr(&y,&y);
-		FP_YYY_sqr(&y,&y);
-		FP_YYY_mul(r,&t,&y);
-	} else {
-		FP_YYY_sqr(&y,&y);
-		FP_YYY_sqr(&y,&y);
-		FP_YYY_mul(r,&y,x);
-	}
+    {
+        // r=x^3.y^8
+        FP_YYY_sqr(&t,x);
+        FP_YYY_mul(&t,&t,x);
+        FP_YYY_sqr(&y,&y);
+        FP_YYY_sqr(&y,&y);
+        FP_YYY_sqr(&y,&y);
+        FP_YYY_mul(r,&t,&y);
+    }
+    else
+    {
+        FP_YYY_sqr(&y,&y);
+        FP_YYY_sqr(&y,&y);
+        FP_YYY_mul(r,&y,x);
+    }
 }
 
 #else
 
 void FP_YYY_pow(FP_YYY *r,FP_YYY *a,BIG_XXX b)
 {
-	sign8 w[1+(NLEN_XXX*BASEBITS_XXX+3)/4];
-	FP_YYY tb[16];
-	BIG_XXX t;
-	int i,nb;
+    sign8 w[1+(NLEN_XXX*BASEBITS_XXX+3)/4];
+    FP_YYY tb[16];
+    BIG_XXX t;
+    int i,nb;
 
-	FP_YYY_norm(a);
+    FP_YYY_norm(a);
     BIG_XXX_norm(b);
-	BIG_XXX_copy(t,b);
-	nb=1+(BIG_XXX_nbits(t)+3)/4;
+    BIG_XXX_copy(t,b);
+    nb=1+(BIG_XXX_nbits(t)+3)/4;
     /* convert exponent to 4-bit window */
     for (i=0; i<nb; i++)
     {
@@ -673,22 +687,22 @@
         BIG_XXX_dec(t,w[i]);
         BIG_XXX_norm(t);
         BIG_XXX_fshr(t,4);
-    }	
+    }
 
-	FP_YYY_one(&tb[0]);
-	FP_YYY_copy(&tb[1],a);
-	for (i=2;i<16;i++)
-		FP_YYY_mul(&tb[i],&tb[i-1],a);
-	
-	FP_YYY_copy(r,&tb[w[nb-1]]);
+    FP_YYY_one(&tb[0]);
+    FP_YYY_copy(&tb[1],a);
+    for (i=2; i<16; i++)
+        FP_YYY_mul(&tb[i],&tb[i-1],a);
+
+    FP_YYY_copy(r,&tb[w[nb-1]]);
     for (i=nb-2; i>=0; i--)
     {
-		FP_YYY_sqr(r,r);
-		FP_YYY_sqr(r,r);
-		FP_YYY_sqr(r,r);
-		FP_YYY_sqr(r,r);
-		FP_YYY_mul(r,r,&tb[w[i]]);
-	}
+        FP_YYY_sqr(r,r);
+        FP_YYY_sqr(r,r);
+        FP_YYY_sqr(r,r);
+        FP_YYY_sqr(r,r);
+        FP_YYY_mul(r,r,&tb[w[i]]);
+    }
     FP_YYY_reduce(r);
 }
 
@@ -696,11 +710,11 @@
 void FP_YYY_inv(FP_YYY *w,FP_YYY *x)
 {
 
-	BIG_XXX m2;
-	BIG_XXX_rcopy(m2,Modulus_YYY);
-	BIG_XXX_dec(m2,2);
-	BIG_XXX_norm(m2);
-	FP_YYY_pow(w,x,m2);
+    BIG_XXX m2;
+    BIG_XXX_rcopy(m2,Modulus_YYY);
+    BIG_XXX_dec(m2,2);
+    BIG_XXX_norm(m2);
+    FP_YYY_pow(w,x,m2);
 }
 #endif
 
@@ -743,25 +757,25 @@
         FP_YYY_copy(&i,a); // i=x
         BIG_XXX_fshl(i.g,1); // i=2x
 #if MODTYPE_YYY == PSEUDO_MERSENNE   || MODTYPE_YYY==GENERALISED_MERSENNE
-		FP_YYY_fpow(&v,&i);
+        FP_YYY_fpow(&v,&i);
 #else
         BIG_XXX_dec(b,5);
         BIG_XXX_norm(b);
-        BIG_XXX_fshr(b,3); // (p-5)/8 
+        BIG_XXX_fshr(b,3); // (p-5)/8
         FP_YYY_pow(&v,&i,b); // v=(2x)^(p-5)/8
 #endif
         FP_YYY_mul(&i,&i,&v); // i=(2x)^(p+3)/8
         FP_YYY_mul(&i,&i,&v); // i=(2x)^(p-1)/4
         BIG_XXX_dec(i.g,1);  // i=(2x)^(p-1)/4 - 1
-        FP_YYY_mul(r,a,&v);  
+        FP_YYY_mul(r,a,&v);
         FP_YYY_mul(r,r,&i);
         FP_YYY_reduce(r);
     }
     if (MOD8_YYY==3 || MOD8_YYY==7)
     {
 #if MODTYPE_YYY == PSEUDO_MERSENNE   || MODTYPE_YYY==GENERALISED_MERSENNE
-		FP_YYY_fpow(r,a);
-		FP_YYY_mul(r,r,a);
+        FP_YYY_fpow(r,a);
+        FP_YYY_mul(r,r,a);
 #else
         BIG_XXX_inc(b,1);
         BIG_XXX_norm(b);
diff --git a/version3/c/fp.h b/version3/c/fp.h
index a7883f2..245e6e5 100644
--- a/version3/c/fp.h
+++ b/version3/c/fp.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file fp.h
+ * @file fp_YYY.h
  * @author Mike Scott
  * @brief FP Header File
  *
diff --git a/version3/c/fp12.c b/version3/c/fp12.c
index 726e9ec..04d39ac 100644
--- a/version3/c/fp12.c
+++ b/version3/c/fp12.c
@@ -82,7 +82,7 @@
     FP4_YYY_copy(&(w->a),&(x->a));
     FP4_YYY_copy(&(w->b),&(x->b));
     FP4_YYY_copy(&(w->c),&(x->c));
-	w->type=x->type;
+    w->type=x->type;
 }
 
 /* FP12 w=1 */
@@ -92,7 +92,7 @@
     FP4_YYY_one(&(w->a));
     FP4_YYY_zero(&(w->b));
     FP4_YYY_zero(&(w->c));
-	w->type=FP_UNITY;
+    w->type=AMCL_FP_UNITY;
 }
 
 void FP12_YYY_zero(FP12_YYY *w)
@@ -100,7 +100,7 @@
     FP4_YYY_zero(&(w->a));
     FP4_YYY_zero(&(w->b));
     FP4_YYY_zero(&(w->c));
-	w->type=FP_ZERO;
+    w->type=AMCL_FP_ZERO;
 }
 
 /* return 1 if x==y, else 0 */
@@ -129,7 +129,7 @@
     FP4_YYY_copy(&(w->a),a);
     FP4_YYY_zero(&(w->b));
     FP4_YYY_zero(&(w->c));
-	w->type=FP_SPARSER;
+    w->type=AMCL_AMCL_FP_SPARSER;
 }
 
 /* Create FP12 from 3 FP4's */
@@ -139,7 +139,7 @@
     FP4_YYY_copy(&(w->a),a);
     FP4_YYY_copy(&(w->b),b);
     FP4_YYY_copy(&(w->c),c);
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
 }
 
 /* Granger-Scott Unitary Squaring. This does not benefit from lazy reduction */
@@ -180,7 +180,7 @@
     FP4_YYY_add(&(w->b),&B,&(w->b));
     FP4_YYY_add(&(w->c),&C,&(w->c));
 
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
     FP12_YYY_reduce(w);	    /* reduce here as in pow function repeated squarings would trigger multiple reductions */
 }
 
@@ -192,11 +192,11 @@
 
     FP4_YYY A,B,C,D;
 
-	if (x->type<=FP_UNITY)
-	{
-		FP12_YYY_copy(w,x);
-		return;
-	}
+    if (x->type<=AMCL_FP_UNITY)
+    {
+        FP12_YYY_copy(w,x);
+        return;
+    }
 
     FP4_YYY_sqr(&A,&(x->a));
     FP4_YYY_mul(&B,&(x->b),&(x->c));
@@ -229,10 +229,10 @@
     FP4_YYY_add(&(w->b),&C,&D);
     FP4_YYY_add(&(w->c),&(w->c),&A);
 
-	if (x->type==FP_SPARSER)
-		w->type=FP_SPARSE;
-	else
-		w->type=FP_DENSE;
+    if (x->type==AMCL_AMCL_FP_SPARSER)
+        w->type=AMCL_FP_SPARSE;
+    else
+        w->type=AMCL_FP_DENSE;
 
     FP12_YYY_norm(w);
 }
@@ -292,7 +292,7 @@
     FP4_YYY_times_i(&z3);
     FP4_YYY_add(&(w->a),&z0,&z3);
 
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
     FP12_YYY_norm(w);
 }
 
@@ -301,278 +301,280 @@
 /* Usually w is denser than y */
 void FP12_YYY_ssmul(FP12_YYY *w,FP12_YYY *y)
 {
-	FP4_YYY z0,z1,z2,z3,t0,t1;
-	if (w->type==FP_UNITY)
-	{
-		FP12_YYY_copy(w,y);
-		return;
-	}
-	if (y->type==FP_UNITY)
-		return;
+    FP4_YYY z0,z1,z2,z3,t0,t1;
+    if (w->type==AMCL_FP_UNITY)
+    {
+        FP12_YYY_copy(w,y);
+        return;
+    }
+    if (y->type==AMCL_FP_UNITY)
+        return;
 
-	if (y->type >= FP_SPARSE)
-	{
-		FP4_YYY_mul(&z0,&(w->a),&(y->a));  // xa.ya   always 11x11
+    if (y->type >= AMCL_FP_SPARSE)
+    {
+        FP4_YYY_mul(&z0,&(w->a),&(y->a));  // xa.ya   always 11x11
 
 #if SEXTIC_TWIST_ZZZ == M_TYPE
-		if (y->type==FP_SPARSE || w->type==FP_SPARSE)
-		{
-			FP2_YYY_mul(&z2.b,&(w->b).b,&(y->b).b);
-			FP2_YYY_zero(&z2.a);
-			if (y->type!=FP_SPARSE)
-				FP2_YYY_mul(&z2.a,&(w->b).b,&(y->b).a);
-			if (w->type!=FP_SPARSE)
-				FP2_YYY_mul(&z2.a,&(w->b).a,&(y->b).b);
-			FP4_YYY_times_i(&z2);
-		}
-		else
+        if (y->type==AMCL_FP_SPARSE || w->type==AMCL_FP_SPARSE)
+        {
+            FP2_YYY_mul(&z2.b,&(w->b).b,&(y->b).b);
+            FP2_YYY_zero(&z2.a);
+            if (y->type!=AMCL_FP_SPARSE)
+                FP2_YYY_mul(&z2.a,&(w->b).b,&(y->b).a);
+            if (w->type!=AMCL_FP_SPARSE)
+                FP2_YYY_mul(&z2.a,&(w->b).a,&(y->b).b);
+            FP4_YYY_times_i(&z2);
+        }
+        else
 #endif
-			FP4_YYY_mul(&z2,&(w->b),&(y->b));  // xb.yb  could be 00x00 or 01x01 or or 10x10 or 11x00 or 11x10 or 11x01 or 11x11 
+            FP4_YYY_mul(&z2,&(w->b),&(y->b));  // xb.yb  could be 00x00 or 01x01 or or 10x10 or 11x00 or 11x10 or 11x01 or 11x11
 
-		FP4_YYY_add(&t0,&(w->a),&(w->b));  // (xa+xb)
-		FP4_YYY_add(&t1,&(y->a),&(y->b));  // (ya+yb)
+        FP4_YYY_add(&t0,&(w->a),&(w->b));  // (xa+xb)
+        FP4_YYY_add(&t1,&(y->a),&(y->b));  // (ya+yb)
 
-		FP4_YYY_norm(&t0);
-		FP4_YYY_norm(&t1);
+        FP4_YYY_norm(&t0);
+        FP4_YYY_norm(&t1);
 
-		FP4_YYY_mul(&z1,&t0,&t1); // (xa+xb)(ya+yb)  always 11x11
-		FP4_YYY_add(&t0,&(w->b),&(w->c));  // (xb+xc)
-		FP4_YYY_add(&t1,&(y->b),&(y->c));  // (yb+yc)
+        FP4_YYY_mul(&z1,&t0,&t1); // (xa+xb)(ya+yb)  always 11x11
+        FP4_YYY_add(&t0,&(w->b),&(w->c));  // (xb+xc)
+        FP4_YYY_add(&t1,&(y->b),&(y->c));  // (yb+yc)
 
-		FP4_YYY_norm(&t0);
-		FP4_YYY_norm(&t1);
+        FP4_YYY_norm(&t0);
+        FP4_YYY_norm(&t1);
 
-		FP4_YYY_mul(&z3,&t0,&t1);	// (xb+xc)(yb+yc)   could be anything...
-		FP4_YYY_neg(&t0,&z0);		// -(xa.ya)
-		FP4_YYY_neg(&t1,&z2);		// -(xb.yb)
+        FP4_YYY_mul(&z3,&t0,&t1);	// (xb+xc)(yb+yc)   could be anything...
+        FP4_YYY_neg(&t0,&z0);		// -(xa.ya)
+        FP4_YYY_neg(&t1,&z2);		// -(xb.yb)
 
-		FP4_YYY_add(&z1,&z1,&t0);  
-		FP4_YYY_add(&(w->b),&z1,&t1); // /wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb)						= xa.yb + xb.ya
+        FP4_YYY_add(&z1,&z1,&t0);
+        FP4_YYY_add(&(w->b),&z1,&t1); // /wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb)						= xa.yb + xb.ya
 
-		FP4_YYY_add(&z3,&z3,&t1);        // (xb+xc)(yb+yc) -(xb.yb)
-		FP4_YYY_add(&z2,&z2,&t0);        // (xb.yb) - (xa.ya)
+        FP4_YYY_add(&z3,&z3,&t1);        // (xb+xc)(yb+yc) -(xb.yb)
+        FP4_YYY_add(&z2,&z2,&t0);        // (xb.yb) - (xa.ya)
 
-		FP4_YYY_add(&t0,&(w->a),&(w->c));  // (xa+xc)
-		FP4_YYY_add(&t1,&(y->a),&(y->c));  // (ya+yc)
+        FP4_YYY_add(&t0,&(w->a),&(w->c));  // (xa+xc)
+        FP4_YYY_add(&t1,&(y->a),&(y->c));  // (ya+yc)
 
-		FP4_YYY_norm(&t0);
-		FP4_YYY_norm(&t1);
+        FP4_YYY_norm(&t0);
+        FP4_YYY_norm(&t1);
 
-		FP4_YYY_mul(&t0,&t1,&t0);	// (xa+xc)(ya+yc)    always 11x11
-		FP4_YYY_add(&z2,&z2,&t0);	// (xb.yb) - (xa.ya) + (xa+xc)(ya+yc)
+        FP4_YYY_mul(&t0,&t1,&t0);	// (xa+xc)(ya+yc)    always 11x11
+        FP4_YYY_add(&z2,&z2,&t0);	// (xb.yb) - (xa.ya) + (xa+xc)(ya+yc)
 
 #if SEXTIC_TWIST_ZZZ == D_TYPE
-		if (y->type==FP_SPARSE || w->type==FP_SPARSE)
-		{
-			FP2_YYY_mul(&t0.a,&(w->c).a,&(y->c).a);
-			FP2_YYY_zero(&t0.b);
-			if (y->type!=FP_SPARSE)
-				FP2_YYY_mul(&t0.b,&(w->c).a,&(y->c).b);
-			if (w->type!=FP_SPARSE)
-				FP2_YYY_mul(&t0.b,&(w->c).b,&(y->c).a);
-		}
-		else
+        if (y->type==AMCL_FP_SPARSE || w->type==AMCL_FP_SPARSE)
+        {
+            FP2_YYY_mul(&t0.a,&(w->c).a,&(y->c).a);
+            FP2_YYY_zero(&t0.b);
+            if (y->type!=AMCL_FP_SPARSE)
+                FP2_YYY_mul(&t0.b,&(w->c).a,&(y->c).b);
+            if (w->type!=AMCL_FP_SPARSE)
+                FP2_YYY_mul(&t0.b,&(w->c).b,&(y->c).a);
+        }
+        else
 #endif
-			FP4_YYY_mul(&t0,&(w->c),&(y->c)); // (xc.yc)  could be anything
-			
-		FP4_YYY_neg(&t1,&t0);			  // -(xc.yc) 
+            FP4_YYY_mul(&t0,&(w->c),&(y->c)); // (xc.yc)  could be anything
 
-		FP4_YYY_add(&(w->c),&z2,&t1);		// wc = (xb.yb) - (xa.ya) + (xa+xc)(ya+yc) - (xc.yc)	=  xb.yb + xc.ya + xa.yc
-		FP4_YYY_add(&z3,&z3,&t1);			// (xb+xc)(yb+yc) -(xb.yb) - (xc.yc)					=  xb.yc + xc.yb
-		FP4_YYY_times_i(&t0);				// i.(xc.yc)
-		FP4_YYY_add(&(w->b),&(w->b),&t0);   // wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb) +i(xc.yc)
-		FP4_YYY_norm(&z3);
-		FP4_YYY_times_i(&z3);				// i[(xb+xc)(yb+yc) -(xb.yb) - (xc.yc)]					= i(xb.yc + xc.yb)
-		FP4_YYY_add(&(w->a),&z0,&z3);		// wa = xa.ya + i(xb.yc + xc.yb)
-	} else {
-		if (w->type==FP_SPARSER)
-		{
-			FP12_YYY_smul(w,y);
-			return;
-		}
- // dense by sparser - 13m 
+        FP4_YYY_neg(&t1,&t0);			  // -(xc.yc)
+
+        FP4_YYY_add(&(w->c),&z2,&t1);		// wc = (xb.yb) - (xa.ya) + (xa+xc)(ya+yc) - (xc.yc)	=  xb.yb + xc.ya + xa.yc
+        FP4_YYY_add(&z3,&z3,&t1);			// (xb+xc)(yb+yc) -(xb.yb) - (xc.yc)					=  xb.yc + xc.yb
+        FP4_YYY_times_i(&t0);				// i.(xc.yc)
+        FP4_YYY_add(&(w->b),&(w->b),&t0);   // wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb) +i(xc.yc)
+        FP4_YYY_norm(&z3);
+        FP4_YYY_times_i(&z3);				// i[(xb+xc)(yb+yc) -(xb.yb) - (xc.yc)]					= i(xb.yc + xc.yb)
+        FP4_YYY_add(&(w->a),&z0,&z3);		// wa = xa.ya + i(xb.yc + xc.yb)
+    }
+    else
+    {
+        if (w->type==AMCL_AMCL_FP_SPARSER)
+        {
+            FP12_YYY_smul(w,y);
+            return;
+        }
+// dense by sparser - 13m
 #if SEXTIC_TWIST_ZZZ == D_TYPE
-		FP4_YYY_copy(&z3,&(w->b));
-		FP4_YYY_mul(&z0,&(w->a),&(y->a));
+        FP4_YYY_copy(&z3,&(w->b));
+        FP4_YYY_mul(&z0,&(w->a),&(y->a));
 
-		FP4_YYY_pmul(&z2,&(w->b),&(y->b).a);
-		FP4_YYY_add(&(w->b),&(w->a),&(w->b));
-		FP4_YYY_copy(&t1,&(y->a));
-		FP2_YYY_add(&t1.a,&t1.a,&(y->b).a);
+        FP4_YYY_pmul(&z2,&(w->b),&(y->b).a);
+        FP4_YYY_add(&(w->b),&(w->a),&(w->b));
+        FP4_YYY_copy(&t1,&(y->a));
+        FP2_YYY_add(&t1.a,&t1.a,&(y->b).a);
 
-		FP4_YYY_norm(&t1);
-		FP4_YYY_norm(&(w->b));
+        FP4_YYY_norm(&t1);
+        FP4_YYY_norm(&(w->b));
 
-		FP4_YYY_mul(&(w->b),&(w->b),&t1);
-		FP4_YYY_add(&z3,&z3,&(w->c));
-		FP4_YYY_norm(&z3);
-		FP4_YYY_pmul(&z3,&z3,&(y->b).a);
-		FP4_YYY_neg(&t0,&z0);
-		FP4_YYY_neg(&t1,&z2);
+        FP4_YYY_mul(&(w->b),&(w->b),&t1);
+        FP4_YYY_add(&z3,&z3,&(w->c));
+        FP4_YYY_norm(&z3);
+        FP4_YYY_pmul(&z3,&z3,&(y->b).a);
+        FP4_YYY_neg(&t0,&z0);
+        FP4_YYY_neg(&t1,&z2);
 
-		FP4_YYY_add(&(w->b),&(w->b),&t0);   // z1=z1-z0
-		FP4_YYY_add(&(w->b),&(w->b),&t1);   // z1=z1-z2
+        FP4_YYY_add(&(w->b),&(w->b),&t0);   // z1=z1-z0
+        FP4_YYY_add(&(w->b),&(w->b),&t1);   // z1=z1-z2
 
-		FP4_YYY_add(&z3,&z3,&t1);        // z3=z3-z2
-		FP4_YYY_add(&z2,&z2,&t0);        // z2=z2-z0
+        FP4_YYY_add(&z3,&z3,&t1);        // z3=z3-z2
+        FP4_YYY_add(&z2,&z2,&t0);        // z2=z2-z0
 
-		FP4_YYY_add(&t0,&(w->a),&(w->c));
-		FP4_YYY_norm(&t0);
-		FP4_YYY_norm(&z3);
+        FP4_YYY_add(&t0,&(w->a),&(w->c));
+        FP4_YYY_norm(&t0);
+        FP4_YYY_norm(&z3);
 
-		FP4_YYY_mul(&t0,&(y->a),&t0);
-		FP4_YYY_add(&(w->c),&z2,&t0);
+        FP4_YYY_mul(&t0,&(y->a),&t0);
+        FP4_YYY_add(&(w->c),&z2,&t0);
 
-		FP4_YYY_times_i(&z3);
-		FP4_YYY_add(&(w->a),&z0,&z3);
+        FP4_YYY_times_i(&z3);
+        FP4_YYY_add(&(w->a),&z0,&z3);
 #endif
 #if SEXTIC_TWIST_ZZZ == M_TYPE
-		FP4_YYY_mul(&z0,&(w->a),&(y->a));
-		FP4_YYY_add(&t0,&(w->a),&(w->b));
-		FP4_YYY_norm(&t0);
+        FP4_YYY_mul(&z0,&(w->a),&(y->a));
+        FP4_YYY_add(&t0,&(w->a),&(w->b));
+        FP4_YYY_norm(&t0);
 
-		FP4_YYY_mul(&z1,&t0,&(y->a));
-		FP4_YYY_add(&t0,&(w->b),&(w->c));
-		FP4_YYY_norm(&t0);
+        FP4_YYY_mul(&z1,&t0,&(y->a));
+        FP4_YYY_add(&t0,&(w->b),&(w->c));
+        FP4_YYY_norm(&t0);
 
-		FP4_YYY_pmul(&z3,&t0,&(y->c).b);
-		FP4_YYY_times_i(&z3);
+        FP4_YYY_pmul(&z3,&t0,&(y->c).b);
+        FP4_YYY_times_i(&z3);
 
-		FP4_YYY_neg(&t0,&z0);
-		FP4_YYY_add(&z1,&z1,&t0);   // z1=z1-z0
+        FP4_YYY_neg(&t0,&z0);
+        FP4_YYY_add(&z1,&z1,&t0);   // z1=z1-z0
 
-		FP4_YYY_copy(&(w->b),&z1);
-		FP4_YYY_copy(&z2,&t0);
+        FP4_YYY_copy(&(w->b),&z1);
+        FP4_YYY_copy(&z2,&t0);
 
-		FP4_YYY_add(&t0,&(w->a),&(w->c));
-		FP4_YYY_add(&t1,&(y->a),&(y->c));
+        FP4_YYY_add(&t0,&(w->a),&(w->c));
+        FP4_YYY_add(&t1,&(y->a),&(y->c));
 
-		FP4_YYY_norm(&t0);
-		FP4_YYY_norm(&t1);
+        FP4_YYY_norm(&t0);
+        FP4_YYY_norm(&t1);
 
-		FP4_YYY_mul(&t0,&t1,&t0);
-		FP4_YYY_add(&z2,&z2,&t0);
+        FP4_YYY_mul(&t0,&t1,&t0);
+        FP4_YYY_add(&z2,&z2,&t0);
 
-		FP4_YYY_pmul(&t0,&(w->c),&(y->c).b);
-		FP4_YYY_times_i(&t0);
-		FP4_YYY_neg(&t1,&t0);
-		FP4_YYY_times_i(&t0);
+        FP4_YYY_pmul(&t0,&(w->c),&(y->c).b);
+        FP4_YYY_times_i(&t0);
+        FP4_YYY_neg(&t1,&t0);
+        FP4_YYY_times_i(&t0);
 
-		FP4_YYY_add(&(w->c),&z2,&t1);
-		FP4_YYY_add(&z3,&z3,&t1);
+        FP4_YYY_add(&(w->c),&z2,&t1);
+        FP4_YYY_add(&z3,&z3,&t1);
 
-		FP4_YYY_add(&(w->b),&(w->b),&t0);
-		FP4_YYY_norm(&z3);
-		FP4_YYY_times_i(&z3);
-		FP4_YYY_add(&(w->a),&z0,&z3);
+        FP4_YYY_add(&(w->b),&(w->b),&t0);
+        FP4_YYY_norm(&z3);
+        FP4_YYY_times_i(&z3);
+        FP4_YYY_add(&(w->a),&z0,&z3);
 
 #endif
-	}
-	w->type=FP_DENSE;
+    }
+    w->type=AMCL_FP_DENSE;
     FP12_YYY_norm(w);
 }
 
 /* FP12 multiplication w=w*y */
 /* catering for special case that arises from special form of ATE pairing line function */
-/* w and y are both sparser line functions - cost = 6m */ 
+/* w and y are both sparser line functions - cost = 6m */
 void FP12_YYY_smul(FP12_YYY *w,FP12_YYY *y)
 {
-	FP2_YYY w1,w2,w3,ta,tb,tc,td,te,t;
+    FP2_YYY w1,w2,w3,ta,tb,tc,td,te,t;
 
 //	if (type==D_TYPE)
-//	{ 
+//	{
 #if SEXTIC_TWIST_ZZZ == D_TYPE
-	FP2_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
-	FP2_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
-	FP2_YYY_mul(&w3,&(w->b).a,&(y->b).a); // C1.C2
+    FP2_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
+    FP2_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
+    FP2_YYY_mul(&w3,&(w->b).a,&(y->b).a); // C1.C2
 
-	FP2_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
-	FP2_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
-	FP2_YYY_norm(&ta);
-	FP2_YYY_norm(&tb);
-	FP2_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
-	FP2_YYY_add(&t,&w1,&w2);
-	FP2_YYY_neg(&t,&t);
-	FP2_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)		
-				
-	FP2_YYY_add(&ta,&(w->a).a,&(w->b).a); // A1+C1
-	FP2_YYY_add(&tb,&(y->a).a,&(y->b).a); // A2+C2
-	FP2_YYY_norm(&ta);
-	FP2_YYY_norm(&tb);
-	FP2_YYY_mul(&td,&ta,&tb);			// (A1+C1)(A2+C2)
-	FP2_YYY_add(&t,&w1,&w3);
-	FP2_YYY_neg(&t,&t);
-	FP2_YYY_add(&td,&td,&t);			// (A1+C1)(A2+C2)-A1.A2-C1*C2 =  (A1.C2+A2.C1)		
+    FP2_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
+    FP2_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
+    FP2_YYY_norm(&ta);
+    FP2_YYY_norm(&tb);
+    FP2_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
+    FP2_YYY_add(&t,&w1,&w2);
+    FP2_YYY_neg(&t,&t);
+    FP2_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)
 
-	FP2_YYY_add(&ta,&(w->a).b,&(w->b).a); // B1+C1
-	FP2_YYY_add(&tb,&(y->a).b,&(y->b).a); // B2+C2
-	FP2_YYY_norm(&ta);
-	FP2_YYY_norm(&tb);
-	FP2_YYY_mul(&te,&ta,&tb);			// (B1+C1)(B2+C2)
-	FP2_YYY_add(&t,&w2,&w3);
-	FP2_YYY_neg(&t,&t);
-	FP2_YYY_add(&te,&te,&t);			// (B1+C1)(B2+C2)-B1.B2-C1*C2 =  (B1.C2+B2.C1)		
+    FP2_YYY_add(&ta,&(w->a).a,&(w->b).a); // A1+C1
+    FP2_YYY_add(&tb,&(y->a).a,&(y->b).a); // A2+C2
+    FP2_YYY_norm(&ta);
+    FP2_YYY_norm(&tb);
+    FP2_YYY_mul(&td,&ta,&tb);			// (A1+C1)(A2+C2)
+    FP2_YYY_add(&t,&w1,&w3);
+    FP2_YYY_neg(&t,&t);
+    FP2_YYY_add(&td,&td,&t);			// (A1+C1)(A2+C2)-A1.A2-C1*C2 =  (A1.C2+A2.C1)
 
-	FP2_YYY_mul_ip(&w2);
-	FP2_YYY_add(&w1,&w1,&w2);
-	FP4_YYY_from_FP2s(&(w->a),&w1,&tc);
-	FP4_YYY_from_FP2s(&(w->b),&td,&te); // only norm these 2
-	FP4_YYY_from_FP2(&(w->c),&w3);
+    FP2_YYY_add(&ta,&(w->a).b,&(w->b).a); // B1+C1
+    FP2_YYY_add(&tb,&(y->a).b,&(y->b).a); // B2+C2
+    FP2_YYY_norm(&ta);
+    FP2_YYY_norm(&tb);
+    FP2_YYY_mul(&te,&ta,&tb);			// (B1+C1)(B2+C2)
+    FP2_YYY_add(&t,&w2,&w3);
+    FP2_YYY_neg(&t,&t);
+    FP2_YYY_add(&te,&te,&t);			// (B1+C1)(B2+C2)-B1.B2-C1*C2 =  (B1.C2+B2.C1)
 
-	FP4_YYY_norm(&(w->a));
-	FP4_YYY_norm(&(w->b));
+    FP2_YYY_mul_ip(&w2);
+    FP2_YYY_add(&w1,&w1,&w2);
+    FP4_YYY_from_FP2s(&(w->a),&w1,&tc);
+    FP4_YYY_from_FP2s(&(w->b),&td,&te); // only norm these 2
+    FP4_YYY_from_FP2(&(w->c),&w3);
+
+    FP4_YYY_norm(&(w->a));
+    FP4_YYY_norm(&(w->b));
 #endif
-//	} else { 
+//	} else {
 #if SEXTIC_TWIST_ZZZ == M_TYPE
-	FP2_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
-	FP2_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
-	FP2_YYY_mul(&w3,&(w->c).b,&(y->c).b); // F1.F2
+    FP2_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
+    FP2_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
+    FP2_YYY_mul(&w3,&(w->c).b,&(y->c).b); // F1.F2
 
-	FP2_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
-	FP2_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
-	FP2_YYY_norm(&ta);
-	FP2_YYY_norm(&tb);
-	FP2_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
-	FP2_YYY_add(&t,&w1,&w2);
-	FP2_YYY_neg(&t,&t);
-	FP2_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)		
-				
-	FP2_YYY_add(&ta,&(w->a).a,&(w->c).b); // A1+F1
-	FP2_YYY_add(&tb,&(y->a).a,&(y->c).b); // A2+F2
-	FP2_YYY_norm(&ta);
-	FP2_YYY_norm(&tb);
-	FP2_YYY_mul(&td,&ta,&tb);			// (A1+F1)(A2+F2)
-	FP2_YYY_add(&t,&w1,&w3);
-	FP2_YYY_neg(&t,&t);
-	FP2_YYY_add(&td,&td,&t);			// (A1+F1)(A2+F2)-A1.A2-F1*F2 =  (A1.F2+A2.F1)		
+    FP2_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
+    FP2_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
+    FP2_YYY_norm(&ta);
+    FP2_YYY_norm(&tb);
+    FP2_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
+    FP2_YYY_add(&t,&w1,&w2);
+    FP2_YYY_neg(&t,&t);
+    FP2_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)
 
-	FP2_YYY_add(&ta,&(w->a).b,&(w->c).b); // B1+F1
-	FP2_YYY_add(&tb,&(y->a).b,&(y->c).b); // B2+F2
-	FP2_YYY_norm(&ta);
-	FP2_YYY_norm(&tb);
-	FP2_YYY_mul(&te,&ta,&tb);			// (B1+F1)(B2+F2)
-	FP2_YYY_add(&t,&w2,&w3);
-	FP2_YYY_neg(&t,&t);
-	FP2_YYY_add(&te,&te,&t);			// (B1+F1)(B2+F2)-B1.B2-F1*F2 =  (B1.F2+B2.F1)	
+    FP2_YYY_add(&ta,&(w->a).a,&(w->c).b); // A1+F1
+    FP2_YYY_add(&tb,&(y->a).a,&(y->c).b); // A2+F2
+    FP2_YYY_norm(&ta);
+    FP2_YYY_norm(&tb);
+    FP2_YYY_mul(&td,&ta,&tb);			// (A1+F1)(A2+F2)
+    FP2_YYY_add(&t,&w1,&w3);
+    FP2_YYY_neg(&t,&t);
+    FP2_YYY_add(&td,&td,&t);			// (A1+F1)(A2+F2)-A1.A2-F1*F2 =  (A1.F2+A2.F1)
 
-	FP2_YYY_mul_ip(&w2);
-	FP2_YYY_add(&w1,&w1,&w2);
-	FP4_YYY_from_FP2s(&(w->a),&w1,&tc);
+    FP2_YYY_add(&ta,&(w->a).b,&(w->c).b); // B1+F1
+    FP2_YYY_add(&tb,&(y->a).b,&(y->c).b); // B2+F2
+    FP2_YYY_norm(&ta);
+    FP2_YYY_norm(&tb);
+    FP2_YYY_mul(&te,&ta,&tb);			// (B1+F1)(B2+F2)
+    FP2_YYY_add(&t,&w2,&w3);
+    FP2_YYY_neg(&t,&t);
+    FP2_YYY_add(&te,&te,&t);			// (B1+F1)(B2+F2)-B1.B2-F1*F2 =  (B1.F2+B2.F1)
 
-	FP2_YYY_mul_ip(&w3);
-	FP2_YYY_norm(&w3);
-	FP4_YYY_from_FP2H(&(w->b),&w3);
+    FP2_YYY_mul_ip(&w2);
+    FP2_YYY_add(&w1,&w1,&w2);
+    FP4_YYY_from_FP2s(&(w->a),&w1,&tc);
 
-	FP2_YYY_norm(&te);
-	FP2_YYY_mul_ip(&te);
-	FP4_YYY_from_FP2s(&(w->c),&te,&td);
+    FP2_YYY_mul_ip(&w3);
+    FP2_YYY_norm(&w3);
+    FP4_YYY_from_FP2H(&(w->b),&w3);
 
-	FP4_YYY_norm(&(w->a));
-	FP4_YYY_norm(&(w->c));
+    FP2_YYY_norm(&te);
+    FP2_YYY_mul_ip(&te);
+    FP4_YYY_from_FP2s(&(w->c),&te,&td);
+
+    FP4_YYY_norm(&(w->a));
+    FP4_YYY_norm(&(w->c));
 #endif
 
 //	}
-	w->type=FP_SPARSE;
+    w->type=AMCL_FP_SPARSE;
 }
 
 /* Set w=1/x */
@@ -613,7 +615,7 @@
     FP4_YYY_mul(&(w->a),&f0,&f3);
     FP4_YYY_mul(&(w->b),&f1,&f3);
     FP4_YYY_mul(&(w->c),&f2,&f3);
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
 }
 
 /* constant time powering by small integer of max length bts */
@@ -692,13 +694,13 @@
     FP12_YYY w,sf;
     BIG_XXX b1,b3;
     int i,nb,bt;
-	BIG_XXX_copy(b1,b);
+    BIG_XXX_copy(b1,b);
     BIG_XXX_norm(b1);
     BIG_XXX_pmul(b3,b1,3);
     BIG_XXX_norm(b3);
 
-	FP12_YYY_copy(&sf,a);
-	FP12_YYY_norm(&sf);
+    FP12_YYY_copy(&sf,a);
+    FP12_YYY_norm(&sf);
     FP12_YYY_copy(&w,&sf);
 
 
@@ -729,8 +731,8 @@
 void FP12_YYY_pow4(FP12_YYY *p,FP12_YYY *q,BIG_XXX u[4])
 {
     int i,j,k,nb,pb,bt;
-	FP12_YYY g[8],r;
-	BIG_XXX t[4],mt;
+    FP12_YYY g[8],r;
+    BIG_XXX t[4],mt;
     sign8 w[NLEN_XXX*BASEBITS_XXX+1];
     sign8 s[NLEN_XXX*BASEBITS_XXX+1];
 
@@ -741,24 +743,24 @@
 // Precomputed table
     FP12_YYY_copy(&g[0],&q[0]); // q[0]
     FP12_YYY_copy(&g[1],&g[0]);
-	FP12_YYY_mul(&g[1],&q[1]);	// q[0].q[1]
+    FP12_YYY_mul(&g[1],&q[1]);	// q[0].q[1]
     FP12_YYY_copy(&g[2],&g[0]);
-	FP12_YYY_mul(&g[2],&q[2]);	// q[0].q[2]
-	FP12_YYY_copy(&g[3],&g[1]);
-	FP12_YYY_mul(&g[3],&q[2]);	// q[0].q[1].q[2]
-	FP12_YYY_copy(&g[4],&g[0]);
-	FP12_YYY_mul(&g[4],&q[3]);  // q[0].q[3]
-	FP12_YYY_copy(&g[5],&g[1]);
-	FP12_YYY_mul(&g[5],&q[3]);	// q[0].q[1].q[3]
-	FP12_YYY_copy(&g[6],&g[2]);
-	FP12_YYY_mul(&g[6],&q[3]);	// q[0].q[2].q[3]
-	FP12_YYY_copy(&g[7],&g[3]);
-	FP12_YYY_mul(&g[7],&q[3]);	// q[0].q[1].q[2].q[3]
+    FP12_YYY_mul(&g[2],&q[2]);	// q[0].q[2]
+    FP12_YYY_copy(&g[3],&g[1]);
+    FP12_YYY_mul(&g[3],&q[2]);	// q[0].q[1].q[2]
+    FP12_YYY_copy(&g[4],&g[0]);
+    FP12_YYY_mul(&g[4],&q[3]);  // q[0].q[3]
+    FP12_YYY_copy(&g[5],&g[1]);
+    FP12_YYY_mul(&g[5],&q[3]);	// q[0].q[1].q[3]
+    FP12_YYY_copy(&g[6],&g[2]);
+    FP12_YYY_mul(&g[6],&q[3]);	// q[0].q[2].q[3]
+    FP12_YYY_copy(&g[7],&g[3]);
+    FP12_YYY_mul(&g[7],&q[3]);	// q[0].q[1].q[2].q[3]
 
 // Make it odd
-	pb=1-BIG_XXX_parity(t[0]);
-	BIG_XXX_inc(t[0],pb);
-	BIG_XXX_norm(t[0]);
+    pb=1-BIG_XXX_parity(t[0]);
+    BIG_XXX_inc(t[0],pb);
+    BIG_XXX_norm(t[0]);
 
 // Number of bits
     BIG_XXX_zero(mt);
@@ -768,45 +770,45 @@
     }
     nb=1+BIG_XXX_nbits(mt);
 
-// Sign pivot 
-	s[nb-1]=1;
-	for (i=0;i<nb-1;i++)
-	{
+// Sign pivot
+    s[nb-1]=1;
+    for (i=0; i<nb-1; i++)
+    {
         BIG_XXX_fshr(t[0],1);
-		s[i]=2*BIG_XXX_parity(t[0])-1;
-	}
+        s[i]=2*BIG_XXX_parity(t[0])-1;
+    }
 
 // Recoded exponent
     for (i=0; i<nb; i++)
     {
-		w[i]=0;
-		k=1;
-		for (j=1; j<4; j++)
-		{
-			bt=s[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w[i]=0;
+        k=1;
+        for (j=1; j<4; j++)
+        {
+            bt=s[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w[i]+=bt*k;
+            k*=2;
         }
-    }		
+    }
 
 // Main loop
-	FP12_YYY_select(p,g,2*w[nb-1]+1);
+    FP12_YYY_select(p,g,2*w[nb-1]+1);
     for (i=nb-2; i>=0; i--)
     {
         FP12_YYY_select(&r,g,2*w[i]+s[i]);
-		FP12_YYY_usqr(p,p);
+        FP12_YYY_usqr(p,p);
         FP12_YYY_mul(p,&r);
     }
 // apply correction
-	FP12_YYY_conj(&r,&q[0]);   
-	FP12_YYY_mul(&r,p);
-	FP12_YYY_cmove(p,&r,pb);
+    FP12_YYY_conj(&r,&q[0]);
+    FP12_YYY_mul(&r,p);
+    FP12_YYY_cmove(p,&r,pb);
 
-	FP12_YYY_reduce(p);
+    FP12_YYY_reduce(p);
 }
 
 /* Set w=w^p using Frobenius */
@@ -823,7 +825,7 @@
 
     FP4_YYY_pmul(&(w->b),&(w->b),f);
     FP4_YYY_pmul(&(w->c),&(w->c),&f2);
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
 }
 
 /* SU= 8 */
@@ -935,7 +937,7 @@
     FP4_YYY_cmove(&(f->a),&(g->a),d);
     FP4_YYY_cmove(&(f->b),&(g->b),d);
     FP4_YYY_cmove(&(f->c),&(g->c),d);
-	d=~(d-1);
-	f->type^=(f->type^g->type)&d;
+    d=~(d-1);
+    f->type^=(f->type^g->type)&d;
 }
 
diff --git a/version3/c/fp12.h b/version3/c/fp12.h
index bc23ec1..5cb5d83 100644
--- a/version3/c/fp12.h
+++ b/version3/c/fp12.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file fp12.h
+ * @file fp12_YYY.h
  * @author Mike Scott
  * @brief FP12 Header File
  *
@@ -38,7 +38,7 @@
     FP4_YYY a; /**< first part of FP12 */
     FP4_YYY b; /**< second part of FP12 */
     FP4_YYY c; /**< third part of FP12 */
-	int type;
+    int type;  /**< Type */
 } FP12_YYY;
 
 extern const BIG_XXX Fra_YYY; /**< real part of BN curve Frobenius Constant */
diff --git a/version3/c/fp16.c b/version3/c/fp16.c
index e2579c9..0f37181 100644
--- a/version3/c/fp16.c
+++ b/version3/c/fp16.c
@@ -100,14 +100,14 @@
 {
     /* Just one field neg */
     FP8_YYY m,t;
-	FP16_YYY_norm(x);
+    FP16_YYY_norm(x);
     FP8_YYY_add(&m,&(x->a),&(x->b));
-	FP8_YYY_norm(&m);
+    FP8_YYY_norm(&m);
     FP8_YYY_neg(&m,&m);
     FP8_YYY_add(&t,&m,&(x->b));
     FP8_YYY_add(&(w->b),&m,&(x->a));
     FP8_YYY_copy(&(w->a),&t);
-	FP16_YYY_norm(w);
+    FP16_YYY_norm(w);
 }
 
 /* Set w=conj(x) */
@@ -115,7 +115,7 @@
 {
     FP8_YYY_copy(&(w->a), &(x->a));
     FP8_YYY_neg(&(w->b), &(x->b));
-	FP16_YYY_norm(w);
+    FP16_YYY_norm(w);
 }
 
 /* Set w=-conj(x) */
@@ -123,7 +123,7 @@
 {
     FP8_YYY_copy(&(w->b),&(x->b));
     FP8_YYY_neg(&(w->a), &(x->a));
-	FP16_YYY_norm(w);
+    FP16_YYY_norm(w);
 }
 
 /* Set w=x+y */
@@ -192,8 +192,8 @@
 
     FP8_YYY_add(&t2,&(x->a),&t2);
 
-	FP8_YYY_norm(&t1);  // 2
-	FP8_YYY_norm(&t2);  // 2
+    FP8_YYY_norm(&t1);  // 2
+    FP8_YYY_norm(&t2);  // 2
 
     FP8_YYY_mul(&(w->a),&t1,&t2);
 
@@ -202,7 +202,7 @@
 
     FP8_YYY_add(&t2,&t2,&t3);
 
-	FP8_YYY_norm(&t2);  // 2
+    FP8_YYY_norm(&t2);  // 2
     FP8_YYY_neg(&t2,&t2);
     FP8_YYY_add(&(w->a),&(w->a),&t2);  /* a=(a+b)(a+i^2.b)-i^2.ab-ab = a*a+ib*ib */
     FP8_YYY_add(&(w->b),&t3,&t3);  /* b=2ab */
@@ -216,23 +216,23 @@
 {
 
     FP8_YYY t1,t2,t3,t4;
-    FP8_YYY_mul(&t1,&(x->a),&(y->a)); 
-    FP8_YYY_mul(&t2,&(x->b),&(y->b)); 
+    FP8_YYY_mul(&t1,&(x->a),&(y->a));
+    FP8_YYY_mul(&t2,&(x->b),&(y->b));
 
     FP8_YYY_add(&t3,&(y->b),&(y->a));
     FP8_YYY_add(&t4,&(x->b),&(x->a));
 
-	FP8_YYY_norm(&t4); // 2
-	FP8_YYY_norm(&t3); // 2
+    FP8_YYY_norm(&t4); // 2
+    FP8_YYY_norm(&t3); // 2
 
     FP8_YYY_mul(&t4,&t4,&t3); /* (xa+xb)(ya+yb) */
 
-	FP8_YYY_neg(&t3,&t1);  // 1
-	FP8_YYY_add(&t4,&t4,&t3);  //t4E=3
+    FP8_YYY_neg(&t3,&t1);  // 1
+    FP8_YYY_add(&t4,&t4,&t3);  //t4E=3
     FP8_YYY_norm(&t4);
 
-	FP8_YYY_neg(&t3,&t2);  // 1
-	FP8_YYY_add(&(w->b),&t4,&t3); //wbE=3
+    FP8_YYY_neg(&t3,&t2);  // 1
+    FP8_YYY_add(&(w->b),&t4,&t3); //wbE=3
 
     FP8_YYY_times_i(&t2);
     FP8_YYY_add(&(w->a),&t2,&t1);
@@ -266,56 +266,57 @@
     FP8_YYY_sqr(&t1,&(x->a));
     FP8_YYY_sqr(&t2,&(x->b));
     FP8_YYY_times_i(&t2);
-	FP8_YYY_norm(&t2);
+    FP8_YYY_norm(&t2);
 
     FP8_YYY_sub(&t1,&t1,&t2);
-	FP8_YYY_norm(&t1);
+    FP8_YYY_norm(&t1);
 
     FP8_YYY_inv(&t1,&t1);
 
     FP8_YYY_mul(&(w->a),&t1,&(x->a));
     FP8_YYY_neg(&t1,&t1);
-	FP8_YYY_norm(&t1);
+    FP8_YYY_norm(&t1);
     FP8_YYY_mul(&(w->b),&t1,&(x->b));
 }
 
 /* w*=i where i = sqrt(sqrt(-1+sqrt(-1))) */
 void FP16_YYY_times_i(FP16_YYY *w)
 {
-	FP8_YYY s,t;
-	FP8_YYY_copy(&s,&(w->b));
-	FP8_YYY_copy(&t,&(w->a));
-	FP8_YYY_times_i(&s);
-	FP8_YYY_copy(&(w->a),&s);
-	FP8_YYY_copy(&(w->b),&t);
-	FP16_YYY_norm(w);
+    FP8_YYY s,t;
+    FP8_YYY_copy(&s,&(w->b));
+    FP8_YYY_copy(&t,&(w->a));
+    FP8_YYY_times_i(&s);
+    FP8_YYY_copy(&(w->a),&s);
+    FP8_YYY_copy(&(w->b),&t);
+    FP16_YYY_norm(w);
 }
 
 void FP16_YYY_times_i2(FP16_YYY *w)
 {
-	FP8_YYY_times_i(&(w->a));
-	FP8_YYY_times_i(&(w->b));
+    FP8_YYY_times_i(&(w->a));
+    FP8_YYY_times_i(&(w->b));
 }
 
 void FP16_YYY_times_i4(FP16_YYY *w)
 {
-	FP8_YYY_times_i2(&(w->a));
-	FP8_YYY_times_i2(&(w->b));
+    FP8_YYY_times_i2(&(w->a));
+    FP8_YYY_times_i2(&(w->b));
 }
 
 /* Set w=w^p using Frobenius */
 void FP16_YYY_frob(FP16_YYY *w,FP2_YYY *f)
-{ // f=(i+1)^(p-3)/8
-	FP2_YYY ff;
+{
+    // f=(i+1)^(p-3)/8
+    FP2_YYY ff;
 
-	FP2_YYY_sqr(&ff,f);  // (i+1)^(p-3)/4
-	FP2_YYY_norm(&ff);
+    FP2_YYY_sqr(&ff,f);  // (i+1)^(p-3)/4
+    FP2_YYY_norm(&ff);
 
-	FP8_YYY_frob(&(w->a),&ff);
-	FP8_YYY_frob(&(w->b),&ff);
+    FP8_YYY_frob(&(w->a),&ff);
+    FP8_YYY_frob(&(w->b),&ff);
 
-	FP8_YYY_qmul(&(w->b),&(w->b),f);  // times (1+i)^(p-3)/8
-	FP8_YYY_times_i(&(w->b));		// (i+1)^(p-1)/8
+    FP8_YYY_qmul(&(w->b),&(w->b),f);  // times (1+i)^(p-3)/8
+    FP8_YYY_times_i(&(w->b));		// (i+1)^(p-1)/8
 }
 
 /* Set r=a^b mod m */
@@ -358,10 +359,10 @@
 
     FP16_YYY_copy(r,x);
     FP16_YYY_sub(&t1,w,y);
-	FP16_YYY_norm(&t1);
+    FP16_YYY_norm(&t1);
     FP16_YYY_pmul(&t1,&t1,&(r->a));
     FP16_YYY_add(&t2,w,y);
-	FP16_YYY_norm(&t2);
+    FP16_YYY_norm(&t2);
     FP16_YYY_pmul(&t2,&t2,&(r->b));
     FP16_YYY_times_i(&t2);
 
@@ -379,7 +380,7 @@
     FP16_YYY_conj(&w,r);
     FP16_YYY_add(&w,&w,&w);
     FP16_YYY_sqr(r,r);
-	FP16_YYY_norm(&w);
+    FP16_YYY_norm(&w);
     FP16_YYY_sub(r,r,&w);
     FP16_YYY_reduce(r);    /* reduce here as multiple calls trigger automatic reductions */
 }
@@ -390,20 +391,20 @@
     int i,par,nb;
     BIG_XXX v;
     FP2_YYY w2;
-	FP4_YYY w4;
-	FP8_YYY w8;
+    FP4_YYY w4;
+    FP8_YYY w8;
     FP16_YYY t,a,b,c,sf;
 
     BIG_XXX_zero(v);
     BIG_XXX_inc(v,3);
-	BIG_XXX_norm(v);
+    BIG_XXX_norm(v);
     FP2_YYY_from_BIG(&w2,v);
     FP4_YYY_from_FP2(&w4,&w2);
-	FP8_YYY_from_FP4(&w8,&w4);
+    FP8_YYY_from_FP4(&w8,&w4);
     FP16_YYY_from_FP8(&a,&w8);
-	FP16_YYY_copy(&sf,x);
-	FP16_YYY_norm(&sf);
-	FP16_YYY_copy(&b,&sf);
+    FP16_YYY_copy(&sf,x);
+    FP16_YYY_norm(&sf);
+    FP16_YYY_copy(&b,&sf);
     FP16_YYY_xtr_D(&c,&sf);
 
 
@@ -455,7 +456,7 @@
     BIG_XXX_copy(e,a);
     BIG_XXX_copy(d,b);
     BIG_XXX_norm(d);
-	BIG_XXX_norm(e);
+    BIG_XXX_norm(e);
     FP16_YYY_copy(&cu,ck);
     FP16_YYY_copy(&cv,cl);
     FP16_YYY_copy(&cumv,ckml);
diff --git a/version3/c/fp2.c b/version3/c/fp2.c
index 0c9cb63..5e7e8eb 100644
--- a/version3/c/fp2.c
+++ b/version3/c/fp2.c
@@ -279,7 +279,6 @@
 /* SU= 128 */
 void FP2_YYY_inv(FP2_YYY *w,FP2_YYY *x)
 {
-    BIG_XXX m,b;
     FP_YYY w1,w2;
 
     FP2_YYY_norm(x);
@@ -287,7 +286,7 @@
     FP_YYY_sqr(&w2,&(x->b));
     FP_YYY_add(&w1,&w1,&w2);
 
-	FP_YYY_inv(&w1,&w1);
+    FP_YYY_inv(&w1,&w1);
 
     FP_YYY_mul(&(w->a),&(x->a),&w1);
     FP_YYY_neg(&w1,&w1);
@@ -384,7 +383,6 @@
 
 int FP2_YYY_sqrt(FP2_YYY *w,FP2_YYY *u)
 {
-    BIG_XXX b;
     FP_YYY w1,w2;
     FP2_YYY_copy(w,u);
     if (FP2_YYY_iszilch(w)) return 1;
@@ -416,7 +414,7 @@
     FP_YYY_copy(&(w->a),&w2);
     FP_YYY_add(&w2,&w2,&w2);
 
-	FP_YYY_inv(&w2,&w2);
+    FP_YYY_inv(&w2,&w2);
 
     FP_YYY_mul(&(w->b),&(w->b),&w2);
     return 1;
diff --git a/version3/c/fp2.h b/version3/c/fp2.h
index 6767685..8442141 100644
--- a/version3/c/fp2.h
+++ b/version3/c/fp2.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file fp2.h
+ * @file fp2_YYY.h
  * @author Mike Scott
  * @brief FP2 Header File
  *
diff --git a/version3/c/fp24.c b/version3/c/fp24.c
index 8711e96..815ce89 100644
--- a/version3/c/fp24.c
+++ b/version3/c/fp24.c
@@ -79,7 +79,7 @@
     FP8_YYY_copy(&(w->a),&(x->a));
     FP8_YYY_copy(&(w->b),&(x->b));
     FP8_YYY_copy(&(w->c),&(x->c));
-	w->type=x->type;
+    w->type=x->type;
 }
 
 /* FP24 w=1 */
@@ -89,7 +89,7 @@
     FP8_YYY_one(&(w->a));
     FP8_YYY_zero(&(w->b));
     FP8_YYY_zero(&(w->c));
-	w->type=FP_UNITY;
+    w->type=AMCL_FP_UNITY;
 }
 
 void FP24_YYY_zero(FP24_YYY *w)
@@ -97,7 +97,7 @@
     FP8_YYY_zero(&(w->a));
     FP8_YYY_zero(&(w->b));
     FP8_YYY_zero(&(w->c));
-	w->type=FP_ZERO;
+    w->type=AMCL_FP_ZERO;
 }
 
 /* return 1 if x==y, else 0 */
@@ -126,7 +126,7 @@
     FP8_YYY_copy(&(w->a),a);
     FP8_YYY_zero(&(w->b));
     FP8_YYY_zero(&(w->c));
-	w->type=FP_SPARSER;
+    w->type=AMCL_AMCL_FP_SPARSER;
 }
 
 /* Create FP24 from 3 FP8's */
@@ -136,7 +136,7 @@
     FP8_YYY_copy(&(w->a),a);
     FP8_YYY_copy(&(w->b),b);
     FP8_YYY_copy(&(w->c),c);
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
 }
 
 /* Granger-Scott Unitary Squaring. This does not benefit from lazy reduction */
@@ -176,7 +176,7 @@
     FP8_YYY_add(&(w->c),&(w->c),&(w->c));
     FP8_YYY_add(&(w->b),&B,&(w->b));
     FP8_YYY_add(&(w->c),&C,&(w->c));
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
     FP24_YYY_reduce(w);	    /* reduce here as in pow function repeated squarings would trigger multiple reductions */
 }
 
@@ -188,16 +188,16 @@
 
     FP8_YYY A,B,C,D;
 
-	if (x->type<=FP_UNITY)
-	{
-		FP24_YYY_copy(w,x);
-		return;
-	}
+    if (x->type<=AMCL_FP_UNITY)
+    {
+        FP24_YYY_copy(w,x);
+        return;
+    }
 
     FP8_YYY_sqr(&A,&(x->a));
     FP8_YYY_mul(&B,&(x->b),&(x->c));
     FP8_YYY_add(&B,&B,&B);
-	FP8_YYY_norm(&B);
+    FP8_YYY_norm(&B);
     FP8_YYY_sqr(&C,&(x->c));
 
     FP8_YYY_mul(&D,&(x->a),&(x->b));
@@ -205,7 +205,7 @@
 
     FP8_YYY_add(&(w->c),&(x->a),&(x->c));
     FP8_YYY_add(&(w->c),&(x->b),&(w->c));
-	FP8_YYY_norm(&(w->c));	
+    FP8_YYY_norm(&(w->c));
 
     FP8_YYY_sqr(&(w->c),&(w->c));
 
@@ -227,10 +227,10 @@
     FP8_YYY_add(&(w->b),&C,&D);
     FP8_YYY_add(&(w->c),&(w->c),&A);
 
-	if (x->type==FP_SPARSER)
-		w->type=FP_SPARSE;
-	else
-		w->type=FP_DENSE;
+    if (x->type==AMCL_AMCL_FP_SPARSER)
+        w->type=AMCL_FP_SPARSE;
+    else
+        w->type=AMCL_FP_DENSE;
 
     FP24_YYY_norm(w);
 }
@@ -250,15 +250,15 @@
     FP8_YYY_add(&t0,&(w->a),&(w->b));
     FP8_YYY_add(&t1,&(y->a),&(y->b));  //
 
-	FP8_YYY_norm(&t0);
-	FP8_YYY_norm(&t1);
+    FP8_YYY_norm(&t0);
+    FP8_YYY_norm(&t1);
 
     FP8_YYY_mul(&z1,&t0,&t1);
     FP8_YYY_add(&t0,&(w->b),&(w->c));
     FP8_YYY_add(&t1,&(y->b),&(y->c));  //
 
-	FP8_YYY_norm(&t0);
-	FP8_YYY_norm(&t1);
+    FP8_YYY_norm(&t0);
+    FP8_YYY_norm(&t1);
 
     FP8_YYY_mul(&z3,&t0,&t1);
 
@@ -273,8 +273,8 @@
     FP8_YYY_add(&t0,&(w->a),&(w->c));
     FP8_YYY_add(&t1,&(y->a),&(y->c));
 
-	FP8_YYY_norm(&t0);
-	FP8_YYY_norm(&t1);
+    FP8_YYY_norm(&t0);
+    FP8_YYY_norm(&t1);
 
     FP8_YYY_mul(&t0,&t1,&t0);
     FP8_YYY_add(&z2,&z2,&t0);
@@ -286,10 +286,10 @@
     FP8_YYY_add(&z3,&z3,&t1);
     FP8_YYY_times_i(&t0);
     FP8_YYY_add(&(w->b),&(w->b),&t0);
-	FP8_YYY_norm(&z3);
+    FP8_YYY_norm(&z3);
     FP8_YYY_times_i(&z3);
     FP8_YYY_add(&(w->a),&z0,&z3);
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
     FP24_YYY_norm(w);
 }
 
@@ -298,274 +298,276 @@
 /* Usually w is denser than y */
 void FP24_YYY_ssmul(FP24_YYY *w,FP24_YYY *y)
 {
-	FP8_YYY z0,z1,z2,z3,t0,t1;
-	if (w->type==FP_UNITY)
-	{
-		FP24_YYY_copy(w,y);
-		return;
-	}
-	if (y->type==FP_UNITY)
-		return;
+    FP8_YYY z0,z1,z2,z3,t0,t1;
+    if (w->type==AMCL_FP_UNITY)
+    {
+        FP24_YYY_copy(w,y);
+        return;
+    }
+    if (y->type==AMCL_FP_UNITY)
+        return;
 
-	if (y->type >= FP_SPARSE)
-	{
-		FP8_YYY_mul(&z0,&(w->a),&(y->a));  // xa.ya   always 11x11
+    if (y->type >= AMCL_FP_SPARSE)
+    {
+        FP8_YYY_mul(&z0,&(w->a),&(y->a));  // xa.ya   always 11x11
 
 #if SEXTIC_TWIST_ZZZ == M_TYPE
-		if (y->type==FP_SPARSE || w->type==FP_SPARSE)
-		{
-			FP4_YYY_mul(&z2.b,&(w->b).b,&(y->b).b);
-			FP4_YYY_zero(&z2.a);
-			if (y->type!=FP_SPARSE)
-				FP4_YYY_mul(&z2.a,&(w->b).b,&(y->b).a);
-			if (w->type!=FP_SPARSE)
-				FP4_YYY_mul(&z2.a,&(w->b).a,&(y->b).b);
-			FP8_YYY_times_i(&z2);
-		}
-		else
-#endif 
-			FP8_YYY_mul(&z2,&(w->b),&(y->b));  // xb.yb  could be 00x00 or 01x01 or or 10x10 or 11x00 or 11x10 or 11x01 or 11x11 
-
-		FP8_YYY_add(&t0,&(w->a),&(w->b));  // (xa+xb)
-		FP8_YYY_add(&t1,&(y->a),&(y->b));  // (ya+yb)
-
-		FP8_YYY_norm(&t0);
-		FP8_YYY_norm(&t1);
-
-		FP8_YYY_mul(&z1,&t0,&t1); // (xa+xb)(ya+yb)  always 11x11
-		FP8_YYY_add(&t0,&(w->b),&(w->c));  // (xb+xc)
-		FP8_YYY_add(&t1,&(y->b),&(y->c));  // (yb+yc)
-
-		FP8_YYY_norm(&t0);
-		FP8_YYY_norm(&t1);
-
-		FP8_YYY_mul(&z3,&t0,&t1);	// (xb+xc)(yb+yc)   could be anything...
-		FP8_YYY_neg(&t0,&z0);		// -(xa.ya)
-		FP8_YYY_neg(&t1,&z2);		// -(xb.yb)
-
-		FP8_YYY_add(&z1,&z1,&t0);  
-		FP8_YYY_add(&(w->b),&z1,&t1); // /wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb)						= xa.yb + xb.ya
-
-		FP8_YYY_add(&z3,&z3,&t1);        // (xb+xc)(yb+yc) -(xb.yb)
-		FP8_YYY_add(&z2,&z2,&t0);        // (xb.yb) - (xa.ya)
-
-		FP8_YYY_add(&t0,&(w->a),&(w->c));  // (xa+xc)
-		FP8_YYY_add(&t1,&(y->a),&(y->c));  // (ya+yc)
-
-		FP8_YYY_norm(&t0);
-		FP8_YYY_norm(&t1);
-
-		FP8_YYY_mul(&t0,&t1,&t0);	// (xa+xc)(ya+yc)    always 11x11
-		FP8_YYY_add(&z2,&z2,&t0);	// (xb.yb) - (xa.ya) + (xa+xc)(ya+yc)
-
-#if SEXTIC_TWIST_ZZZ == D_TYPE
-		if (y->type==FP_SPARSE || w->type==FP_SPARSE)
-		{
-			FP4_YYY_mul(&t0.a,&(w->c).a,&(y->c).a);
-			FP4_YYY_zero(&t0.b);
-			if (y->type!=FP_SPARSE)
-				FP4_YYY_mul(&t0.b,&(w->c).a,&(y->c).b);
-			if (w->type!=FP_SPARSE)
-				FP4_YYY_mul(&t0.b,&(w->c).b,&(y->c).a);
-		}
-		else
+        if (y->type==AMCL_FP_SPARSE || w->type==AMCL_FP_SPARSE)
+        {
+            FP4_YYY_mul(&z2.b,&(w->b).b,&(y->b).b);
+            FP4_YYY_zero(&z2.a);
+            if (y->type!=AMCL_FP_SPARSE)
+                FP4_YYY_mul(&z2.a,&(w->b).b,&(y->b).a);
+            if (w->type!=AMCL_FP_SPARSE)
+                FP4_YYY_mul(&z2.a,&(w->b).a,&(y->b).b);
+            FP8_YYY_times_i(&z2);
+        }
+        else
 #endif
-			FP8_YYY_mul(&t0,&(w->c),&(y->c)); // (xc.yc)  could be anything
-			
-		FP8_YYY_neg(&t1,&t0);			  // -(xc.yc) 
+            FP8_YYY_mul(&z2,&(w->b),&(y->b));  // xb.yb  could be 00x00 or 01x01 or or 10x10 or 11x00 or 11x10 or 11x01 or 11x11
 
-		FP8_YYY_add(&(w->c),&z2,&t1);		// wc = (xb.yb) - (xa.ya) + (xa+xc)(ya+yc) - (xc.yc)	=  xb.yb + xc.ya + xa.yc
-		FP8_YYY_add(&z3,&z3,&t1);			// (xb+xc)(yb+yc) -(xb.yb) - (xc.yc)					=  xb.yc + xc.yb
-		FP8_YYY_times_i(&t0);				// i.(xc.yc)
-		FP8_YYY_add(&(w->b),&(w->b),&t0);   // wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb) +i(xc.yc)
-		FP8_YYY_norm(&z3);
-		FP8_YYY_times_i(&z3);				// i[(xb+xc)(yb+yc) -(xb.yb) - (xc.yc)]					= i(xb.yc + xc.yb)
-		FP8_YYY_add(&(w->a),&z0,&z3);		// wa = xa.ya + i(xb.yc + xc.yb)
-	} else {
-		if (w->type==FP_SPARSER)
-		{
-			FP24_YYY_smul(w,y);
-			return;
-		}
-// dense by sparser - 13m 
+        FP8_YYY_add(&t0,&(w->a),&(w->b));  // (xa+xb)
+        FP8_YYY_add(&t1,&(y->a),&(y->b));  // (ya+yb)
+
+        FP8_YYY_norm(&t0);
+        FP8_YYY_norm(&t1);
+
+        FP8_YYY_mul(&z1,&t0,&t1); // (xa+xb)(ya+yb)  always 11x11
+        FP8_YYY_add(&t0,&(w->b),&(w->c));  // (xb+xc)
+        FP8_YYY_add(&t1,&(y->b),&(y->c));  // (yb+yc)
+
+        FP8_YYY_norm(&t0);
+        FP8_YYY_norm(&t1);
+
+        FP8_YYY_mul(&z3,&t0,&t1);	// (xb+xc)(yb+yc)   could be anything...
+        FP8_YYY_neg(&t0,&z0);		// -(xa.ya)
+        FP8_YYY_neg(&t1,&z2);		// -(xb.yb)
+
+        FP8_YYY_add(&z1,&z1,&t0);
+        FP8_YYY_add(&(w->b),&z1,&t1); // /wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb)						= xa.yb + xb.ya
+
+        FP8_YYY_add(&z3,&z3,&t1);        // (xb+xc)(yb+yc) -(xb.yb)
+        FP8_YYY_add(&z2,&z2,&t0);        // (xb.yb) - (xa.ya)
+
+        FP8_YYY_add(&t0,&(w->a),&(w->c));  // (xa+xc)
+        FP8_YYY_add(&t1,&(y->a),&(y->c));  // (ya+yc)
+
+        FP8_YYY_norm(&t0);
+        FP8_YYY_norm(&t1);
+
+        FP8_YYY_mul(&t0,&t1,&t0);	// (xa+xc)(ya+yc)    always 11x11
+        FP8_YYY_add(&z2,&z2,&t0);	// (xb.yb) - (xa.ya) + (xa+xc)(ya+yc)
+
 #if SEXTIC_TWIST_ZZZ == D_TYPE
-		FP8_YYY_copy(&z3,&(w->b));
-		FP8_YYY_mul(&z0,&(w->a),&(y->a));
+        if (y->type==AMCL_FP_SPARSE || w->type==AMCL_FP_SPARSE)
+        {
+            FP4_YYY_mul(&t0.a,&(w->c).a,&(y->c).a);
+            FP4_YYY_zero(&t0.b);
+            if (y->type!=AMCL_FP_SPARSE)
+                FP4_YYY_mul(&t0.b,&(w->c).a,&(y->c).b);
+            if (w->type!=AMCL_FP_SPARSE)
+                FP4_YYY_mul(&t0.b,&(w->c).b,&(y->c).a);
+        }
+        else
+#endif
+            FP8_YYY_mul(&t0,&(w->c),&(y->c)); // (xc.yc)  could be anything
 
-		FP8_YYY_pmul(&z2,&(w->b),&(y->b).a);
-		FP8_YYY_add(&(w->b),&(w->a),&(w->b));
-		FP8_YYY_copy(&t1,&(y->a));
-		FP4_YYY_add(&t1.a,&t1.a,&(y->b).a);
+        FP8_YYY_neg(&t1,&t0);			  // -(xc.yc)
 
-		FP8_YYY_norm(&t1);
-		FP8_YYY_norm(&(w->b));
+        FP8_YYY_add(&(w->c),&z2,&t1);		// wc = (xb.yb) - (xa.ya) + (xa+xc)(ya+yc) - (xc.yc)	=  xb.yb + xc.ya + xa.yc
+        FP8_YYY_add(&z3,&z3,&t1);			// (xb+xc)(yb+yc) -(xb.yb) - (xc.yc)					=  xb.yc + xc.yb
+        FP8_YYY_times_i(&t0);				// i.(xc.yc)
+        FP8_YYY_add(&(w->b),&(w->b),&t0);   // wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb) +i(xc.yc)
+        FP8_YYY_norm(&z3);
+        FP8_YYY_times_i(&z3);				// i[(xb+xc)(yb+yc) -(xb.yb) - (xc.yc)]					= i(xb.yc + xc.yb)
+        FP8_YYY_add(&(w->a),&z0,&z3);		// wa = xa.ya + i(xb.yc + xc.yb)
+    }
+    else
+    {
+        if (w->type==AMCL_AMCL_FP_SPARSER)
+        {
+            FP24_YYY_smul(w,y);
+            return;
+        }
+// dense by sparser - 13m
+#if SEXTIC_TWIST_ZZZ == D_TYPE
+        FP8_YYY_copy(&z3,&(w->b));
+        FP8_YYY_mul(&z0,&(w->a),&(y->a));
 
-		FP8_YYY_mul(&(w->b),&(w->b),&t1);
-		FP8_YYY_add(&z3,&z3,&(w->c));
-		FP8_YYY_norm(&z3);
-		FP8_YYY_pmul(&z3,&z3,&(y->b).a);
-		FP8_YYY_neg(&t0,&z0);
-		FP8_YYY_neg(&t1,&z2);
+        FP8_YYY_pmul(&z2,&(w->b),&(y->b).a);
+        FP8_YYY_add(&(w->b),&(w->a),&(w->b));
+        FP8_YYY_copy(&t1,&(y->a));
+        FP4_YYY_add(&t1.a,&t1.a,&(y->b).a);
 
-		FP8_YYY_add(&(w->b),&(w->b),&t0);   // z1=z1-z0
-		FP8_YYY_add(&(w->b),&(w->b),&t1);   // z1=z1-z2
+        FP8_YYY_norm(&t1);
+        FP8_YYY_norm(&(w->b));
 
-		FP8_YYY_add(&z3,&z3,&t1);        // z3=z3-z2
-		FP8_YYY_add(&z2,&z2,&t0);        // z2=z2-z0
+        FP8_YYY_mul(&(w->b),&(w->b),&t1);
+        FP8_YYY_add(&z3,&z3,&(w->c));
+        FP8_YYY_norm(&z3);
+        FP8_YYY_pmul(&z3,&z3,&(y->b).a);
+        FP8_YYY_neg(&t0,&z0);
+        FP8_YYY_neg(&t1,&z2);
 
-		FP8_YYY_add(&t0,&(w->a),&(w->c));
-		FP8_YYY_norm(&t0);
-		FP8_YYY_norm(&z3);
+        FP8_YYY_add(&(w->b),&(w->b),&t0);   // z1=z1-z0
+        FP8_YYY_add(&(w->b),&(w->b),&t1);   // z1=z1-z2
 
-		FP8_YYY_mul(&t0,&(y->a),&t0);
-		FP8_YYY_add(&(w->c),&z2,&t0);
+        FP8_YYY_add(&z3,&z3,&t1);        // z3=z3-z2
+        FP8_YYY_add(&z2,&z2,&t0);        // z2=z2-z0
 
-		FP8_YYY_times_i(&z3);
-		FP8_YYY_add(&(w->a),&z0,&z3);
+        FP8_YYY_add(&t0,&(w->a),&(w->c));
+        FP8_YYY_norm(&t0);
+        FP8_YYY_norm(&z3);
+
+        FP8_YYY_mul(&t0,&(y->a),&t0);
+        FP8_YYY_add(&(w->c),&z2,&t0);
+
+        FP8_YYY_times_i(&z3);
+        FP8_YYY_add(&(w->a),&z0,&z3);
 #endif
 #if SEXTIC_TWIST_ZZZ == M_TYPE
-		FP8_YYY_mul(&z0,&(w->a),&(y->a));
-		FP8_YYY_add(&t0,&(w->a),&(w->b));
-		FP8_YYY_norm(&t0);
+        FP8_YYY_mul(&z0,&(w->a),&(y->a));
+        FP8_YYY_add(&t0,&(w->a),&(w->b));
+        FP8_YYY_norm(&t0);
 
-		FP8_YYY_mul(&z1,&t0,&(y->a));
-		FP8_YYY_add(&t0,&(w->b),&(w->c));
-		FP8_YYY_norm(&t0);
+        FP8_YYY_mul(&z1,&t0,&(y->a));
+        FP8_YYY_add(&t0,&(w->b),&(w->c));
+        FP8_YYY_norm(&t0);
 
-		FP8_YYY_pmul(&z3,&t0,&(y->c).b);
-		FP8_YYY_times_i(&z3);
+        FP8_YYY_pmul(&z3,&t0,&(y->c).b);
+        FP8_YYY_times_i(&z3);
 
-		FP8_YYY_neg(&t0,&z0);
-		FP8_YYY_add(&z1,&z1,&t0);   // z1=z1-z0
+        FP8_YYY_neg(&t0,&z0);
+        FP8_YYY_add(&z1,&z1,&t0);   // z1=z1-z0
 
-		FP8_YYY_copy(&(w->b),&z1);
-		FP8_YYY_copy(&z2,&t0);
+        FP8_YYY_copy(&(w->b),&z1);
+        FP8_YYY_copy(&z2,&t0);
 
-		FP8_YYY_add(&t0,&(w->a),&(w->c));
-		FP8_YYY_add(&t1,&(y->a),&(y->c));
+        FP8_YYY_add(&t0,&(w->a),&(w->c));
+        FP8_YYY_add(&t1,&(y->a),&(y->c));
 
-		FP8_YYY_norm(&t0);
-		FP8_YYY_norm(&t1);
+        FP8_YYY_norm(&t0);
+        FP8_YYY_norm(&t1);
 
-		FP8_YYY_mul(&t0,&t1,&t0);
-		FP8_YYY_add(&z2,&z2,&t0);
+        FP8_YYY_mul(&t0,&t1,&t0);
+        FP8_YYY_add(&z2,&z2,&t0);
 
-		FP8_YYY_pmul(&t0,&(w->c),&(y->c).b);
-		FP8_YYY_times_i(&t0);
-		FP8_YYY_neg(&t1,&t0);
-		FP8_YYY_times_i(&t0);
+        FP8_YYY_pmul(&t0,&(w->c),&(y->c).b);
+        FP8_YYY_times_i(&t0);
+        FP8_YYY_neg(&t1,&t0);
+        FP8_YYY_times_i(&t0);
 
-		FP8_YYY_add(&(w->c),&z2,&t1);
-		FP8_YYY_add(&z3,&z3,&t1);
+        FP8_YYY_add(&(w->c),&z2,&t1);
+        FP8_YYY_add(&z3,&z3,&t1);
 
-		FP8_YYY_add(&(w->b),&(w->b),&t0);
-		FP8_YYY_norm(&z3);
-		FP8_YYY_times_i(&z3);
-		FP8_YYY_add(&(w->a),&z0,&z3);
+        FP8_YYY_add(&(w->b),&(w->b),&t0);
+        FP8_YYY_norm(&z3);
+        FP8_YYY_times_i(&z3);
+        FP8_YYY_add(&(w->a),&z0,&z3);
 #endif
-	}
-	w->type=FP_DENSE;
+    }
+    w->type=AMCL_FP_DENSE;
     FP24_YYY_norm(w);
 }
 
 /* FP24 multiplication w=w*y */
 /* catering for special case that arises from special form of ATE pairing line function */
-/* w and y are both sparser line functions - cost = 6m */ 
+/* w and y are both sparser line functions - cost = 6m */
 void FP24_YYY_smul(FP24_YYY *w,FP24_YYY *y)
 {
-	FP4_YYY w1,w2,w3,ta,tb,tc,td,te,t;
+    FP4_YYY w1,w2,w3,ta,tb,tc,td,te,t;
 
 
 #if SEXTIC_TWIST_ZZZ == D_TYPE
-	FP4_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
-	FP4_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
-	FP4_YYY_mul(&w3,&(w->b).a,&(y->b).a); // C1.C2
+    FP4_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
+    FP4_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
+    FP4_YYY_mul(&w3,&(w->b).a,&(y->b).a); // C1.C2
 
-	FP4_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
-	FP4_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
-	FP4_YYY_norm(&ta);
-	FP4_YYY_norm(&tb);
-	FP4_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
-	FP4_YYY_add(&t,&w1,&w2);
-	FP4_YYY_neg(&t,&t);
-	FP4_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)		
-				
-	FP4_YYY_add(&ta,&(w->a).a,&(w->b).a); // A1+C1
-	FP4_YYY_add(&tb,&(y->a).a,&(y->b).a); // A2+C2
-	FP4_YYY_norm(&ta);
-	FP4_YYY_norm(&tb);
-	FP4_YYY_mul(&td,&ta,&tb);			// (A1+C1)(A2+C2)
-	FP4_YYY_add(&t,&w1,&w3);
-	FP4_YYY_neg(&t,&t);
-	FP4_YYY_add(&td,&td,&t);			// (A1+C1)(A2+C2)-A1.A2-C1*C2 =  (A1.C2+A2.C1)		
+    FP4_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
+    FP4_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
+    FP4_YYY_norm(&ta);
+    FP4_YYY_norm(&tb);
+    FP4_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
+    FP4_YYY_add(&t,&w1,&w2);
+    FP4_YYY_neg(&t,&t);
+    FP4_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)
 
-	FP4_YYY_add(&ta,&(w->a).b,&(w->b).a); // B1+C1
-	FP4_YYY_add(&tb,&(y->a).b,&(y->b).a); // B2+C2
-	FP4_YYY_norm(&ta);
-	FP4_YYY_norm(&tb);
-	FP4_YYY_mul(&te,&ta,&tb);			// (B1+C1)(B2+C2)
-	FP4_YYY_add(&t,&w2,&w3);
-	FP4_YYY_neg(&t,&t);
-	FP4_YYY_add(&te,&te,&t);			// (B1+C1)(B2+C2)-B1.B2-C1*C2 =  (B1.C2+B2.C1)		
+    FP4_YYY_add(&ta,&(w->a).a,&(w->b).a); // A1+C1
+    FP4_YYY_add(&tb,&(y->a).a,&(y->b).a); // A2+C2
+    FP4_YYY_norm(&ta);
+    FP4_YYY_norm(&tb);
+    FP4_YYY_mul(&td,&ta,&tb);			// (A1+C1)(A2+C2)
+    FP4_YYY_add(&t,&w1,&w3);
+    FP4_YYY_neg(&t,&t);
+    FP4_YYY_add(&td,&td,&t);			// (A1+C1)(A2+C2)-A1.A2-C1*C2 =  (A1.C2+A2.C1)
 
-	FP4_YYY_times_i(&w2);
-	FP4_YYY_add(&w1,&w1,&w2);
-	FP8_YYY_from_FP4s(&(w->a),&w1,&tc);
-	FP8_YYY_from_FP4s(&(w->b),&td,&te); // only norm these 2
-	FP8_YYY_from_FP4(&(w->c),&w3);
+    FP4_YYY_add(&ta,&(w->a).b,&(w->b).a); // B1+C1
+    FP4_YYY_add(&tb,&(y->a).b,&(y->b).a); // B2+C2
+    FP4_YYY_norm(&ta);
+    FP4_YYY_norm(&tb);
+    FP4_YYY_mul(&te,&ta,&tb);			// (B1+C1)(B2+C2)
+    FP4_YYY_add(&t,&w2,&w3);
+    FP4_YYY_neg(&t,&t);
+    FP4_YYY_add(&te,&te,&t);			// (B1+C1)(B2+C2)-B1.B2-C1*C2 =  (B1.C2+B2.C1)
 
-	FP8_YYY_norm(&(w->a));
-	FP8_YYY_norm(&(w->b));
+    FP4_YYY_times_i(&w2);
+    FP4_YYY_add(&w1,&w1,&w2);
+    FP8_YYY_from_FP4s(&(w->a),&w1,&tc);
+    FP8_YYY_from_FP4s(&(w->b),&td,&te); // only norm these 2
+    FP8_YYY_from_FP4(&(w->c),&w3);
+
+    FP8_YYY_norm(&(w->a));
+    FP8_YYY_norm(&(w->b));
 #endif
 #if SEXTIC_TWIST_ZZZ == M_TYPE
-	FP4_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
-	FP4_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
-	FP4_YYY_mul(&w3,&(w->c).b,&(y->c).b); // F1.F2
+    FP4_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
+    FP4_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
+    FP4_YYY_mul(&w3,&(w->c).b,&(y->c).b); // F1.F2
 
-	FP4_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
-	FP4_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
-	FP4_YYY_norm(&ta);
-	FP4_YYY_norm(&tb);
-	FP4_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
-	FP4_YYY_add(&t,&w1,&w2);
-	FP4_YYY_neg(&t,&t);
-	FP4_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)		
-				
-	FP4_YYY_add(&ta,&(w->a).a,&(w->c).b); // A1+F1
-	FP4_YYY_add(&tb,&(y->a).a,&(y->c).b); // A2+F2
-	FP4_YYY_norm(&ta);
-	FP4_YYY_norm(&tb);
-	FP4_YYY_mul(&td,&ta,&tb);			// (A1+F1)(A2+F2)
-	FP4_YYY_add(&t,&w1,&w3);
-	FP4_YYY_neg(&t,&t);
-	FP4_YYY_add(&td,&td,&t);			// (A1+F1)(A2+F2)-A1.A2-F1*F2 =  (A1.F2+A2.F1)		
+    FP4_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
+    FP4_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
+    FP4_YYY_norm(&ta);
+    FP4_YYY_norm(&tb);
+    FP4_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
+    FP4_YYY_add(&t,&w1,&w2);
+    FP4_YYY_neg(&t,&t);
+    FP4_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)
 
-	FP4_YYY_add(&ta,&(w->a).b,&(w->c).b); // B1+F1
-	FP4_YYY_add(&tb,&(y->a).b,&(y->c).b); // B2+F2
-	FP4_YYY_norm(&ta);
-	FP4_YYY_norm(&tb);
-	FP4_YYY_mul(&te,&ta,&tb);			// (B1+F1)(B2+F2)
-	FP4_YYY_add(&t,&w2,&w3);
-	FP4_YYY_neg(&t,&t);
-	FP4_YYY_add(&te,&te,&t);			// (B1+F1)(B2+F2)-B1.B2-F1*F2 =  (B1.F2+B2.F1)	
+    FP4_YYY_add(&ta,&(w->a).a,&(w->c).b); // A1+F1
+    FP4_YYY_add(&tb,&(y->a).a,&(y->c).b); // A2+F2
+    FP4_YYY_norm(&ta);
+    FP4_YYY_norm(&tb);
+    FP4_YYY_mul(&td,&ta,&tb);			// (A1+F1)(A2+F2)
+    FP4_YYY_add(&t,&w1,&w3);
+    FP4_YYY_neg(&t,&t);
+    FP4_YYY_add(&td,&td,&t);			// (A1+F1)(A2+F2)-A1.A2-F1*F2 =  (A1.F2+A2.F1)
 
-	FP4_YYY_times_i(&w2);
-	FP4_YYY_add(&w1,&w1,&w2);
-	FP8_YYY_from_FP4s(&(w->a),&w1,&tc);
+    FP4_YYY_add(&ta,&(w->a).b,&(w->c).b); // B1+F1
+    FP4_YYY_add(&tb,&(y->a).b,&(y->c).b); // B2+F2
+    FP4_YYY_norm(&ta);
+    FP4_YYY_norm(&tb);
+    FP4_YYY_mul(&te,&ta,&tb);			// (B1+F1)(B2+F2)
+    FP4_YYY_add(&t,&w2,&w3);
+    FP4_YYY_neg(&t,&t);
+    FP4_YYY_add(&te,&te,&t);			// (B1+F1)(B2+F2)-B1.B2-F1*F2 =  (B1.F2+B2.F1)
 
-	FP4_YYY_times_i(&w3);
-	FP4_YYY_norm(&w3);
-	FP8_YYY_from_FP4H(&(w->b),&w3);
+    FP4_YYY_times_i(&w2);
+    FP4_YYY_add(&w1,&w1,&w2);
+    FP8_YYY_from_FP4s(&(w->a),&w1,&tc);
 
-	FP4_YYY_norm(&te);
-	FP4_YYY_times_i(&te);
-	FP8_YYY_from_FP4s(&(w->c),&te,&td);
+    FP4_YYY_times_i(&w3);
+    FP4_YYY_norm(&w3);
+    FP8_YYY_from_FP4H(&(w->b),&w3);
 
-	FP8_YYY_norm(&(w->a));
-	FP8_YYY_norm(&(w->c));
+    FP4_YYY_norm(&te);
+    FP4_YYY_times_i(&te);
+    FP8_YYY_from_FP4s(&(w->c),&te,&td);
+
+    FP8_YYY_norm(&(w->a));
+    FP8_YYY_norm(&(w->c));
 #endif
 
-	w->type=FP_SPARSE;
+    w->type=AMCL_FP_SPARSE;
 }
 
 /* Set w=1/x */
@@ -578,18 +580,18 @@
     FP8_YYY_mul(&f1,&(x->b),&(x->c));
     FP8_YYY_times_i(&f1);
     FP8_YYY_sub(&f0,&f0,&f1);  /* y.a */
-	FP8_YYY_norm(&f0); 		
+    FP8_YYY_norm(&f0);
 
     FP8_YYY_sqr(&f1,&(x->c));
     FP8_YYY_times_i(&f1);
     FP8_YYY_mul(&f2,&(x->a),&(x->b));
     FP8_YYY_sub(&f1,&f1,&f2);  /* y.b */
-	FP8_YYY_norm(&f1); 
+    FP8_YYY_norm(&f1);
 
     FP8_YYY_sqr(&f2,&(x->b));
     FP8_YYY_mul(&f3,&(x->a),&(x->c));
     FP8_YYY_sub(&f2,&f2,&f3);  /* y.c */
-	FP8_YYY_norm(&f2); 
+    FP8_YYY_norm(&f2);
 
     FP8_YYY_mul(&f3,&(x->b),&f2);
     FP8_YYY_times_i(&f3);
@@ -599,13 +601,13 @@
     FP8_YYY_times_i(&(w->c));
 
     FP8_YYY_add(&f3,&(w->c),&f3);
-	FP8_YYY_norm(&f3);
-	
+    FP8_YYY_norm(&f3);
+
     FP8_YYY_inv(&f3,&f3);
     FP8_YYY_mul(&(w->a),&f0,&f3);
     FP8_YYY_mul(&(w->b),&f1,&f3);
     FP8_YYY_mul(&(w->c),&f2,&f3);
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
 }
 
 /* constant time powering by small integer of max length bts */
@@ -632,9 +634,9 @@
 void FP24_YYY_compow(FP8_YYY *c,FP24_YYY *x,BIG_XXX e,BIG_XXX r)
 {
     FP24_YYY g1,g2;
-	FP8_YYY cp,cpm1,cpm2;
+    FP8_YYY cp,cpm1,cpm2;
     FP2_YYY f;
-	BIG_XXX q,a,b,m;
+    BIG_XXX q,a,b,m;
 
     BIG_XXX_rcopy(a,Fra_YYY);
     BIG_XXX_rcopy(b,Frb_YYY);
@@ -643,7 +645,7 @@
     BIG_XXX_rcopy(q,Modulus_YYY);
 
     FP24_YYY_copy(&g1,x);
-	FP24_YYY_copy(&g2,x);
+    FP24_YYY_copy(&g2,x);
 
     BIG_XXX_copy(m,q);
     BIG_XXX_mod(m,r);
@@ -656,11 +658,11 @@
 
     FP24_YYY_trace(c,&g1);
 
-	if (BIG_XXX_iszilch(b))
-	{
-		FP8_YYY_xtr_pow(c,c,e);
-		return;
-	}
+    if (BIG_XXX_iszilch(b))
+    {
+        FP8_YYY_xtr_pow(c,c,e);
+        return;
+    }
 
     FP24_YYY_frob(&g2,&f,1);
     FP24_YYY_trace(&cp,&g2);
@@ -682,33 +684,33 @@
     FP24_YYY w,sf;
     BIG_XXX b1,b3;
     int i,nb,bt;
-	BIG_XXX_copy(b1,b);
+    BIG_XXX_copy(b1,b);
     BIG_XXX_norm(b1);
-	BIG_XXX_pmul(b3,b1,3);
-	BIG_XXX_norm(b3);
+    BIG_XXX_pmul(b3,b1,3);
+    BIG_XXX_norm(b3);
 
-	FP24_YYY_copy(&sf,a);
-	FP24_YYY_norm(&sf);
+    FP24_YYY_copy(&sf,a);
+    FP24_YYY_norm(&sf);
     FP24_YYY_copy(&w,&sf);
 
 
-	nb=BIG_XXX_nbits(b3);
-	for (i=nb-2;i>=1;i--)
-	{
-		FP24_YYY_usqr(&w,&w);
-		bt=BIG_XXX_bit(b3,i)-BIG_XXX_bit(b1,i);
-		if (bt==1)
-			FP24_YYY_mul(&w,&sf);
-		if (bt==-1)
-		{
-			FP24_YYY_conj(&sf,&sf);
-			FP24_YYY_mul(&w,&sf);
-			FP24_YYY_conj(&sf,&sf);
-		}
-	}
+    nb=BIG_XXX_nbits(b3);
+    for (i=nb-2; i>=1; i--)
+    {
+        FP24_YYY_usqr(&w,&w);
+        bt=BIG_XXX_bit(b3,i)-BIG_XXX_bit(b1,i);
+        if (bt==1)
+            FP24_YYY_mul(&w,&sf);
+        if (bt==-1)
+        {
+            FP24_YYY_conj(&sf,&sf);
+            FP24_YYY_mul(&w,&sf);
+            FP24_YYY_conj(&sf,&sf);
+        }
+    }
 
-	FP24_YYY_copy(r,&w);
-	FP24_YYY_reduce(r);
+    FP24_YYY_copy(r,&w);
+    FP24_YYY_reduce(r);
 }
 
 /* p=q0^u0.q1^u1.q2^u2.q3^u3... */
@@ -719,14 +721,14 @@
 void FP24_YYY_pow8(FP24_YYY *p,FP24_YYY *q,BIG_XXX u[8])
 {
     int i,j,k,nb,pb1,pb2,bt;
-	FP24_YYY g1[8],g2[8],r;
-	BIG_XXX t[8],mt;
+    FP24_YYY g1[8],g2[8],r;
+    BIG_XXX t[8],mt;
     sign8 w1[NLEN_XXX*BASEBITS_XXX+1];
     sign8 s1[NLEN_XXX*BASEBITS_XXX+1];
     sign8 w2[NLEN_XXX*BASEBITS_XXX+1];
     sign8 s2[NLEN_XXX*BASEBITS_XXX+1];
     FP_YYY fx,fy;
-	FP2_YYY X;
+    FP2_YYY X;
 
     FP_YYY_rcopy(&fx,Fra_YYY);
     FP_YYY_rcopy(&fy,Frb_YYY);
@@ -738,36 +740,36 @@
 // Precomputed table
     FP24_YYY_copy(&g1[0],&q[0]); // q[0]
     FP24_YYY_copy(&g1[1],&g1[0]);
-	FP24_YYY_mul(&g1[1],&q[1]);	// q[0].q[1]
+    FP24_YYY_mul(&g1[1],&q[1]);	// q[0].q[1]
     FP24_YYY_copy(&g1[2],&g1[0]);
-	FP24_YYY_mul(&g1[2],&q[2]);	// q[0].q[2]
-	FP24_YYY_copy(&g1[3],&g1[1]);
-	FP24_YYY_mul(&g1[3],&q[2]);	// q[0].q[1].q[2]
-	FP24_YYY_copy(&g1[4],&g1[0]);
-	FP24_YYY_mul(&g1[4],&q[3]);  // q[0].q[3]
-	FP24_YYY_copy(&g1[5],&g1[1]);
-	FP24_YYY_mul(&g1[5],&q[3]);	// q[0].q[1].q[3]
-	FP24_YYY_copy(&g1[6],&g1[2]);
-	FP24_YYY_mul(&g1[6],&q[3]);	// q[0].q[2].q[3]
-	FP24_YYY_copy(&g1[7],&g1[3]);
-	FP24_YYY_mul(&g1[7],&q[3]);	// q[0].q[1].q[2].q[3]
+    FP24_YYY_mul(&g1[2],&q[2]);	// q[0].q[2]
+    FP24_YYY_copy(&g1[3],&g1[1]);
+    FP24_YYY_mul(&g1[3],&q[2]);	// q[0].q[1].q[2]
+    FP24_YYY_copy(&g1[4],&g1[0]);
+    FP24_YYY_mul(&g1[4],&q[3]);  // q[0].q[3]
+    FP24_YYY_copy(&g1[5],&g1[1]);
+    FP24_YYY_mul(&g1[5],&q[3]);	// q[0].q[1].q[3]
+    FP24_YYY_copy(&g1[6],&g1[2]);
+    FP24_YYY_mul(&g1[6],&q[3]);	// q[0].q[2].q[3]
+    FP24_YYY_copy(&g1[7],&g1[3]);
+    FP24_YYY_mul(&g1[7],&q[3]);	// q[0].q[1].q[2].q[3]
 
 // Use Frobenius
 
-	for (i=0;i<8;i++)
-	{
-		FP24_YYY_copy(&g2[i],&g1[i]);
-		FP24_YYY_frob(&g2[i],&X,4);
-	}
+    for (i=0; i<8; i++)
+    {
+        FP24_YYY_copy(&g2[i],&g1[i]);
+        FP24_YYY_frob(&g2[i],&X,4);
+    }
 
 // Make it odd
-	pb1=1-BIG_XXX_parity(t[0]);
-	BIG_XXX_inc(t[0],pb1);
-	BIG_XXX_norm(t[0]);
+    pb1=1-BIG_XXX_parity(t[0]);
+    BIG_XXX_inc(t[0],pb1);
+    BIG_XXX_norm(t[0]);
 
-	pb2=1-BIG_XXX_parity(t[4]);
-	BIG_XXX_inc(t[4],pb2);
-	BIG_XXX_norm(t[4]);
+    pb2=1-BIG_XXX_parity(t[4]);
+    BIG_XXX_inc(t[4],pb2);
+    BIG_XXX_norm(t[4]);
 
 // Number of bits
     BIG_XXX_zero(mt);
@@ -777,54 +779,54 @@
     }
     nb=1+BIG_XXX_nbits(mt);
 
-// Sign pivot 
-	s1[nb-1]=1;
-	s2[nb-1]=1;
-	for (i=0;i<nb-1;i++)
-	{
+// Sign pivot
+    s1[nb-1]=1;
+    s2[nb-1]=1;
+    for (i=0; i<nb-1; i++)
+    {
         BIG_XXX_fshr(t[0],1);
-		s1[i]=2*BIG_XXX_parity(t[0])-1;
+        s1[i]=2*BIG_XXX_parity(t[0])-1;
         BIG_XXX_fshr(t[4],1);
-		s2[i]=2*BIG_XXX_parity(t[4])-1;
-	}
+        s2[i]=2*BIG_XXX_parity(t[4])-1;
+    }
 
 // Recoded exponents
     for (i=0; i<nb; i++)
     {
-		w1[i]=0;
-		k=1;
-		for (j=1; j<4; j++)
-		{
-			bt=s1[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w1[i]=0;
+        k=1;
+        for (j=1; j<4; j++)
+        {
+            bt=s1[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w1[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w1[i]+=bt*k;
+            k*=2;
         }
 
-		w2[i]=0;
-		k=1;
-		for (j=5; j<8; j++)
-		{
-			bt=s2[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w2[i]=0;
+        k=1;
+        for (j=5; j<8; j++)
+        {
+            bt=s2[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w2[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w2[i]+=bt*k;
+            k*=2;
         }
-    }	
+    }
 
 // Main loop
-	FP24_YYY_select(p,g1,2*w1[nb-1]+1);
-	FP24_YYY_select(&r,g2,2*w2[nb-1]+1);
-	FP24_YYY_mul(p,&r);
+    FP24_YYY_select(p,g1,2*w1[nb-1]+1);
+    FP24_YYY_select(&r,g2,2*w2[nb-1]+1);
+    FP24_YYY_mul(p,&r);
     for (i=nb-2; i>=0; i--)
     {
-		FP24_YYY_usqr(p,p);
+        FP24_YYY_usqr(p,p);
         FP24_YYY_select(&r,g1,2*w1[i]+s1[i]);
         FP24_YYY_mul(p,&r);
         FP24_YYY_select(&r,g2,2*w2[i]+s2[i]);
@@ -832,39 +834,41 @@
     }
 
 // apply correction
-	FP24_YYY_conj(&r,&q[0]);   
-	FP24_YYY_mul(&r,p);
-	FP24_YYY_cmove(p,&r,pb1);
-	FP24_YYY_conj(&r,&q[4]);   
-	FP24_YYY_mul(&r,p);
-	FP24_YYY_cmove(p,&r,pb2);
+    FP24_YYY_conj(&r,&q[0]);
+    FP24_YYY_mul(&r,p);
+    FP24_YYY_cmove(p,&r,pb1);
+    FP24_YYY_conj(&r,&q[4]);
+    FP24_YYY_mul(&r,p);
+    FP24_YYY_cmove(p,&r,pb2);
 
-	FP24_YYY_reduce(p);
+    FP24_YYY_reduce(p);
 }
 
 /* Set w=w^p using Frobenius */
 /* SU= 160 */
 void FP24_YYY_frob(FP24_YYY *w,FP2_YYY *f,int n)
 {
-	int i;
-	FP4_YYY X2,X4;
+    int i;
     FP2_YYY f3,f2;				// f=(1+i)^(p-7)/12
-    FP2_YYY_sqr(&f2,f);     // 
+    FP2_YYY_sqr(&f2,f);     //
     FP2_YYY_mul(&f3,&f2,f); // f3=f^3=(1+i)^(p-7)/4
 
-	FP2_YYY_mul_ip(&f3);    // f3 = (1+i).f3 = (1+i)^(p-3)/4 
-	FP2_YYY_norm(&f3);
+    FP2_YYY_mul_ip(&f3);    // f3 = (1+i).f3 = (1+i)^(p-3)/4
+    FP2_YYY_norm(&f3);
 
-	for (i=0;i<n;i++)
-	{
-		FP8_YYY_frob(&(w->a),&f3);   // a=a^p
-		FP8_YYY_frob(&(w->b),&f3);   // b=b^p
-		FP8_YYY_frob(&(w->c),&f3);   // c=c^p
-  
-		FP8_YYY_qmul(&(w->b),&(w->b),f); FP8_YYY_times_i2(&(w->b));
-		FP8_YYY_qmul(&(w->c),&(w->c),&f2); FP8_YYY_times_i2(&(w->c)); FP8_YYY_times_i2(&(w->c));
-	}
-	w->type=FP_DENSE;
+    for (i=0; i<n; i++)
+    {
+        FP8_YYY_frob(&(w->a),&f3);   // a=a^p
+        FP8_YYY_frob(&(w->b),&f3);   // b=b^p
+        FP8_YYY_frob(&(w->c),&f3);   // c=c^p
+
+        FP8_YYY_qmul(&(w->b),&(w->b),f);
+        FP8_YYY_times_i2(&(w->b));
+        FP8_YYY_qmul(&(w->c),&(w->c),&f2);
+        FP8_YYY_times_i2(&(w->c));
+        FP8_YYY_times_i2(&(w->c));
+    }
+    w->type=AMCL_FP_DENSE;
 }
 
 /* SU= 8 */
@@ -969,7 +973,7 @@
 /* Restore g from octet string w */
 void FP24_YYY_fromOctet(FP24_YYY *g,octet *W)
 {
-	BIG_XXX b;
+    BIG_XXX b;
 
     BIG_XXX_fromBytes(b,&W->val[0]);
     FP_YYY_nres(&(g->a.a.a.a),b);
@@ -1029,7 +1033,7 @@
     FP8_YYY_cmove(&(f->a),&(g->a),d);
     FP8_YYY_cmove(&(f->b),&(g->b),d);
     FP8_YYY_cmove(&(f->c),&(g->c),d);
-	d=~(d-1);
-	f->type^=(f->type^g->type)&d;
+    d=~(d-1);
+    f->type^=(f->type^g->type)&d;
 }
 
diff --git a/version3/c/fp24.h b/version3/c/fp24.h
index 12b0209..3a9fbd3 100644
--- a/version3/c/fp24.h
+++ b/version3/c/fp24.h
@@ -12,7 +12,7 @@
     FP8_YYY a; /**< first part of FP12 */
     FP8_YYY b; /**< second part of FP12 */
     FP8_YYY c; /**< third part of FP12 */
-	int type;
+    int type;
 } FP24_YYY;
 
 extern const BIG_XXX Fra_YYY; /**< real part of BN curve Frobenius Constant */
@@ -134,7 +134,7 @@
  */
 extern void FP24_YYY_pinpow(FP24_YYY *x,int i,int b);
 
-/**	@brief Raises an FP24 instance x to a BIG power, compressed to FP8 
+/**	@brief Raises an FP24 instance x to a BIG power, compressed to FP8
  *
 	@param c FP8 instance, on exit = x^(e mod r) as FP8
 	@param x FP24 input
diff --git a/version3/c/fp4.c b/version3/c/fp4.c
index 7b05c9e..c1c54f0 100644
--- a/version3/c/fp4.c
+++ b/version3/c/fp4.c
@@ -110,7 +110,7 @@
 {
     /* Just one field neg */
     FP2_YYY m,t;
-	FP4_YYY_norm(x);
+    FP4_YYY_norm(x);
     FP2_YYY_add(&m,&(x->a),&(x->b));
     FP2_YYY_neg(&m,&m);
     FP2_YYY_add(&t,&m,&(x->b));
@@ -334,7 +334,7 @@
     BIG_XXX_copy(z,b);
     BIG_XXX_norm(z);
     FP4_YYY_copy(&w,a);
-	FP4_YYY_norm(&w);
+    FP4_YYY_norm(&w);
     FP4_YYY_one(r);
 
     while(1)
@@ -397,14 +397,14 @@
     FP2_YYY_from_BIG(&w,v);
     FP4_YYY_from_FP2(&a,&w);
 
-	FP4_YYY_copy(&sf,x);
-	FP4_YYY_norm(&sf);
+    FP4_YYY_copy(&sf,x);
+    FP4_YYY_norm(&sf);
     FP4_YYY_copy(&b,&sf);
     FP4_YYY_xtr_D(&c,&sf);
 
     par=BIG_XXX_parity(n);
     BIG_XXX_copy(v,n);
-	BIG_XXX_norm(v);
+    BIG_XXX_norm(v);
     BIG_XXX_shr(v,1);
     if (par==0)
     {
@@ -600,7 +600,7 @@
     FP4_YYY_copy(r,x);
     if (FP4_YYY_iszilch(x))
         return 1;
-    
+
     FP2_YYY_copy(&a,&(x->a));
     FP2_YYY_copy(&s,&(x->b));
 
@@ -662,14 +662,14 @@
 
 void FP4_YYY_div_2i(FP4_YYY *f)
 {
-	FP2_YYY u,v;
-	FP2_YYY_copy(&u,&(f->a));
-	FP2_YYY_copy(&v,&(f->b));
-	FP2_YYY_div_ip2(&u);
-	FP2_YYY_add(&v,&v,&v);
-	FP2_YYY_norm(&v);
-	FP2_YYY_copy(&(f->a),&v);
-	FP2_YYY_copy(&(f->b),&u);
+    FP2_YYY u,v;
+    FP2_YYY_copy(&u,&(f->a));
+    FP2_YYY_copy(&v,&(f->b));
+    FP2_YYY_div_ip2(&u);
+    FP2_YYY_add(&v,&v,&v);
+    FP2_YYY_norm(&v);
+    FP2_YYY_copy(&(f->a),&v);
+    FP2_YYY_copy(&(f->b),&u);
 }
 
 #endif
diff --git a/version3/c/fp4.h b/version3/c/fp4.h
index 451ab4a..4c6dda9 100644
--- a/version3/c/fp4.h
+++ b/version3/c/fp4.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file fp4.h
+ * @file fp4_YYY.h
  * @author Mike Scott
  * @brief FP4 Header File
  *
diff --git a/version3/c/fp48.c b/version3/c/fp48.c
index e99257c..8083bf5 100644
--- a/version3/c/fp48.c
+++ b/version3/c/fp48.c
@@ -80,7 +80,7 @@
     FP16_YYY_copy(&(w->a),&(x->a));
     FP16_YYY_copy(&(w->b),&(x->b));
     FP16_YYY_copy(&(w->c),&(x->c));
-	w->type=x->type;
+    w->type=x->type;
 }
 
 /* FP48 w=1 */
@@ -90,7 +90,7 @@
     FP16_YYY_one(&(w->a));
     FP16_YYY_zero(&(w->b));
     FP16_YYY_zero(&(w->c));
-	w->type=FP_UNITY;
+    w->type=AMCL_FP_UNITY;
 }
 
 void FP48_YYY_zero(FP48_YYY *w)
@@ -98,7 +98,7 @@
     FP16_YYY_zero(&(w->a));
     FP16_YYY_zero(&(w->b));
     FP16_YYY_zero(&(w->c));
-	w->type=FP_ZERO;
+    w->type=AMCL_FP_ZERO;
 }
 
 /* return 1 if x==y, else 0 */
@@ -127,7 +127,7 @@
     FP16_YYY_copy(&(w->a),a);
     FP16_YYY_zero(&(w->b));
     FP16_YYY_zero(&(w->c));
-	w->type=FP_SPARSER;
+    w->type=AMCL_AMCL_FP_SPARSER;
 }
 
 /* Create FP48 from 3 FP16's */
@@ -137,7 +137,7 @@
     FP16_YYY_copy(&(w->a),a);
     FP16_YYY_copy(&(w->b),b);
     FP16_YYY_copy(&(w->c),c);
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
 }
 
 /* Granger-Scott Unitary Squaring. This does not benefit from lazy reduction */
@@ -177,7 +177,7 @@
     FP16_YYY_add(&(w->c),&(w->c),&(w->c));
     FP16_YYY_add(&(w->b),&B,&(w->b));
     FP16_YYY_add(&(w->c),&C,&(w->c));
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
     FP48_YYY_reduce(w);	    /* reduce here as in pow function repeated squarings would trigger multiple reductions */
 }
 
@@ -189,16 +189,16 @@
 
     FP16_YYY A,B,C,D;
 
-	if (x->type<=FP_UNITY)
-	{
-		FP48_YYY_copy(w,x);
-		return;
-	}
+    if (x->type<=AMCL_FP_UNITY)
+    {
+        FP48_YYY_copy(w,x);
+        return;
+    }
 
     FP16_YYY_sqr(&A,&(x->a));
     FP16_YYY_mul(&B,&(x->b),&(x->c));
     FP16_YYY_add(&B,&B,&B);
-	FP16_YYY_norm(&B);
+    FP16_YYY_norm(&B);
     FP16_YYY_sqr(&C,&(x->c));
 
     FP16_YYY_mul(&D,&(x->a),&(x->b));
@@ -206,7 +206,7 @@
 
     FP16_YYY_add(&(w->c),&(x->a),&(x->c));
     FP16_YYY_add(&(w->c),&(x->b),&(w->c));
-	FP16_YYY_norm(&(w->c));	
+    FP16_YYY_norm(&(w->c));
 
     FP16_YYY_sqr(&(w->c),&(w->c));
 
@@ -228,10 +228,10 @@
     FP16_YYY_add(&(w->b),&C,&D);
     FP16_YYY_add(&(w->c),&(w->c),&A);
 
-	if (x->type==FP_SPARSER)
-		w->type=FP_SPARSE;
-	else
-		w->type=FP_DENSE;
+    if (x->type==AMCL_AMCL_FP_SPARSER)
+        w->type=AMCL_FP_SPARSE;
+    else
+        w->type=AMCL_FP_DENSE;
 
     FP48_YYY_norm(w);
 }
@@ -251,15 +251,15 @@
     FP16_YYY_add(&t0,&(w->a),&(w->b));
     FP16_YYY_add(&t1,&(y->a),&(y->b));  //
 
-	FP16_YYY_norm(&t0);
-	FP16_YYY_norm(&t1);
+    FP16_YYY_norm(&t0);
+    FP16_YYY_norm(&t1);
 
     FP16_YYY_mul(&z1,&t0,&t1);
     FP16_YYY_add(&t0,&(w->b),&(w->c));
     FP16_YYY_add(&t1,&(y->b),&(y->c));  //
 
-	FP16_YYY_norm(&t0);
-	FP16_YYY_norm(&t1);
+    FP16_YYY_norm(&t0);
+    FP16_YYY_norm(&t1);
 
     FP16_YYY_mul(&z3,&t0,&t1);
 
@@ -274,8 +274,8 @@
     FP16_YYY_add(&t0,&(w->a),&(w->c));
     FP16_YYY_add(&t1,&(y->a),&(y->c));
 
-	FP16_YYY_norm(&t0);
-	FP16_YYY_norm(&t1);
+    FP16_YYY_norm(&t0);
+    FP16_YYY_norm(&t1);
 
     FP16_YYY_mul(&t0,&t1,&t0);
     FP16_YYY_add(&z2,&z2,&t0);
@@ -287,10 +287,10 @@
     FP16_YYY_add(&z3,&z3,&t1);
     FP16_YYY_times_i(&t0);
     FP16_YYY_add(&(w->b),&(w->b),&t0);
-	FP16_YYY_norm(&z3);
+    FP16_YYY_norm(&z3);
     FP16_YYY_times_i(&z3);
     FP16_YYY_add(&(w->a),&z0,&z3);
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
     FP48_YYY_norm(w);
 }
 
@@ -299,274 +299,276 @@
 /* Usually w is denser than y */
 void FP48_YYY_ssmul(FP48_YYY *w,FP48_YYY *y)
 {
-	FP16_YYY z0,z1,z2,z3,t0,t1;
-	if (w->type==FP_UNITY)
-	{
-		FP48_YYY_copy(w,y);
-		return;
-	}
-	if (y->type==FP_UNITY)
-		return;
+    FP16_YYY z0,z1,z2,z3,t0,t1;
+    if (w->type==AMCL_FP_UNITY)
+    {
+        FP48_YYY_copy(w,y);
+        return;
+    }
+    if (y->type==AMCL_FP_UNITY)
+        return;
 
-	if (y->type >= FP_SPARSE)
-	{
-		FP16_YYY_mul(&z0,&(w->a),&(y->a));  // xa.ya   always 11x11
+    if (y->type >= AMCL_FP_SPARSE)
+    {
+        FP16_YYY_mul(&z0,&(w->a),&(y->a));  // xa.ya   always 11x11
 
 #if SEXTIC_TWIST_ZZZ == M_TYPE
-		if (y->type==FP_SPARSE || w->type==FP_SPARSE)
-		{
-			FP8_YYY_mul(&z2.b,&(w->b).b,&(y->b).b);
-			FP8_YYY_zero(&z2.a);
-			if (y->type!=FP_SPARSE)
-				FP8_YYY_mul(&z2.a,&(w->b).b,&(y->b).a);
-			if (w->type!=FP_SPARSE)
-				FP8_YYY_mul(&z2.a,&(w->b).a,&(y->b).b);
-			FP16_YYY_times_i(&z2);
-		}
-		else
-#endif 
-			FP16_YYY_mul(&z2,&(w->b),&(y->b));  // xb.yb  could be 00x00 or 01x01 or or 10x10 or 11x00 or 11x10 or 11x01 or 11x11 
-
-		FP16_YYY_add(&t0,&(w->a),&(w->b));  // (xa+xb)
-		FP16_YYY_add(&t1,&(y->a),&(y->b));  // (ya+yb)
-
-		FP16_YYY_norm(&t0);
-		FP16_YYY_norm(&t1);
-
-		FP16_YYY_mul(&z1,&t0,&t1); // (xa+xb)(ya+yb)  always 11x11
-		FP16_YYY_add(&t0,&(w->b),&(w->c));  // (xb+xc)
-		FP16_YYY_add(&t1,&(y->b),&(y->c));  // (yb+yc)
-
-		FP16_YYY_norm(&t0);
-		FP16_YYY_norm(&t1);
-
-		FP16_YYY_mul(&z3,&t0,&t1);	// (xb+xc)(yb+yc)   could be anything...
-		FP16_YYY_neg(&t0,&z0);		// -(xa.ya)
-		FP16_YYY_neg(&t1,&z2);		// -(xb.yb)
-
-		FP16_YYY_add(&z1,&z1,&t0);  
-		FP16_YYY_add(&(w->b),&z1,&t1); // /wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb)						= xa.yb + xb.ya
-
-		FP16_YYY_add(&z3,&z3,&t1);        // (xb+xc)(yb+yc) -(xb.yb)
-		FP16_YYY_add(&z2,&z2,&t0);        // (xb.yb) - (xa.ya)
-
-		FP16_YYY_add(&t0,&(w->a),&(w->c));  // (xa+xc)
-		FP16_YYY_add(&t1,&(y->a),&(y->c));  // (ya+yc)
-
-		FP16_YYY_norm(&t0);
-		FP16_YYY_norm(&t1);
-
-		FP16_YYY_mul(&t0,&t1,&t0);	// (xa+xc)(ya+yc)    always 11x11
-		FP16_YYY_add(&z2,&z2,&t0);	// (xb.yb) - (xa.ya) + (xa+xc)(ya+yc)
-
-#if SEXTIC_TWIST_ZZZ == D_TYPE
-		if (y->type==FP_SPARSE || w->type==FP_SPARSE)
-		{
-			FP8_YYY_mul(&t0.a,&(w->c).a,&(y->c).a);
-			FP8_YYY_zero(&t0.b);
-			if (y->type!=FP_SPARSE)
-				FP8_YYY_mul(&t0.b,&(w->c).a,&(y->c).b);
-			if (w->type!=FP_SPARSE)
-				FP8_YYY_mul(&t0.b,&(w->c).b,&(y->c).a);
-		}
-		else
+        if (y->type==AMCL_FP_SPARSE || w->type==AMCL_FP_SPARSE)
+        {
+            FP8_YYY_mul(&z2.b,&(w->b).b,&(y->b).b);
+            FP8_YYY_zero(&z2.a);
+            if (y->type!=AMCL_FP_SPARSE)
+                FP8_YYY_mul(&z2.a,&(w->b).b,&(y->b).a);
+            if (w->type!=AMCL_FP_SPARSE)
+                FP8_YYY_mul(&z2.a,&(w->b).a,&(y->b).b);
+            FP16_YYY_times_i(&z2);
+        }
+        else
 #endif
-			FP16_YYY_mul(&t0,&(w->c),&(y->c)); // (xc.yc)  could be anything
-			
-		FP16_YYY_neg(&t1,&t0);			  // -(xc.yc) 
+            FP16_YYY_mul(&z2,&(w->b),&(y->b));  // xb.yb  could be 00x00 or 01x01 or or 10x10 or 11x00 or 11x10 or 11x01 or 11x11
 
-		FP16_YYY_add(&(w->c),&z2,&t1);		// wc = (xb.yb) - (xa.ya) + (xa+xc)(ya+yc) - (xc.yc)	=  xb.yb + xc.ya + xa.yc
-		FP16_YYY_add(&z3,&z3,&t1);			// (xb+xc)(yb+yc) -(xb.yb) - (xc.yc)					=  xb.yc + xc.yb
-		FP16_YYY_times_i(&t0);				// i.(xc.yc)
-		FP16_YYY_add(&(w->b),&(w->b),&t0);   // wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb) +i(xc.yc)
-		FP16_YYY_norm(&z3);
-		FP16_YYY_times_i(&z3);				// i[(xb+xc)(yb+yc) -(xb.yb) - (xc.yc)]					= i(xb.yc + xc.yb)
-		FP16_YYY_add(&(w->a),&z0,&z3);		// wa = xa.ya + i(xb.yc + xc.yb)
-	} else {
-		if (w->type==FP_SPARSER)
-		{
-			FP48_YYY_smul(w,y);
-			return;
-		}
-// dense by sparser - 13m 
+        FP16_YYY_add(&t0,&(w->a),&(w->b));  // (xa+xb)
+        FP16_YYY_add(&t1,&(y->a),&(y->b));  // (ya+yb)
+
+        FP16_YYY_norm(&t0);
+        FP16_YYY_norm(&t1);
+
+        FP16_YYY_mul(&z1,&t0,&t1); // (xa+xb)(ya+yb)  always 11x11
+        FP16_YYY_add(&t0,&(w->b),&(w->c));  // (xb+xc)
+        FP16_YYY_add(&t1,&(y->b),&(y->c));  // (yb+yc)
+
+        FP16_YYY_norm(&t0);
+        FP16_YYY_norm(&t1);
+
+        FP16_YYY_mul(&z3,&t0,&t1);	// (xb+xc)(yb+yc)   could be anything...
+        FP16_YYY_neg(&t0,&z0);		// -(xa.ya)
+        FP16_YYY_neg(&t1,&z2);		// -(xb.yb)
+
+        FP16_YYY_add(&z1,&z1,&t0);
+        FP16_YYY_add(&(w->b),&z1,&t1); // /wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb)						= xa.yb + xb.ya
+
+        FP16_YYY_add(&z3,&z3,&t1);        // (xb+xc)(yb+yc) -(xb.yb)
+        FP16_YYY_add(&z2,&z2,&t0);        // (xb.yb) - (xa.ya)
+
+        FP16_YYY_add(&t0,&(w->a),&(w->c));  // (xa+xc)
+        FP16_YYY_add(&t1,&(y->a),&(y->c));  // (ya+yc)
+
+        FP16_YYY_norm(&t0);
+        FP16_YYY_norm(&t1);
+
+        FP16_YYY_mul(&t0,&t1,&t0);	// (xa+xc)(ya+yc)    always 11x11
+        FP16_YYY_add(&z2,&z2,&t0);	// (xb.yb) - (xa.ya) + (xa+xc)(ya+yc)
+
 #if SEXTIC_TWIST_ZZZ == D_TYPE
-		FP16_YYY_copy(&z3,&(w->b));
-		FP16_YYY_mul(&z0,&(w->a),&(y->a));
+        if (y->type==AMCL_FP_SPARSE || w->type==AMCL_FP_SPARSE)
+        {
+            FP8_YYY_mul(&t0.a,&(w->c).a,&(y->c).a);
+            FP8_YYY_zero(&t0.b);
+            if (y->type!=AMCL_FP_SPARSE)
+                FP8_YYY_mul(&t0.b,&(w->c).a,&(y->c).b);
+            if (w->type!=AMCL_FP_SPARSE)
+                FP8_YYY_mul(&t0.b,&(w->c).b,&(y->c).a);
+        }
+        else
+#endif
+            FP16_YYY_mul(&t0,&(w->c),&(y->c)); // (xc.yc)  could be anything
 
-		FP16_YYY_pmul(&z2,&(w->b),&(y->b).a);
-		FP16_YYY_add(&(w->b),&(w->a),&(w->b));
-		FP16_YYY_copy(&t1,&(y->a));
-		FP8_YYY_add(&t1.a,&t1.a,&(y->b).a);
+        FP16_YYY_neg(&t1,&t0);			  // -(xc.yc)
 
-		FP16_YYY_norm(&t1);
-		FP16_YYY_norm(&(w->b));
+        FP16_YYY_add(&(w->c),&z2,&t1);		// wc = (xb.yb) - (xa.ya) + (xa+xc)(ya+yc) - (xc.yc)	=  xb.yb + xc.ya + xa.yc
+        FP16_YYY_add(&z3,&z3,&t1);			// (xb+xc)(yb+yc) -(xb.yb) - (xc.yc)					=  xb.yc + xc.yb
+        FP16_YYY_times_i(&t0);				// i.(xc.yc)
+        FP16_YYY_add(&(w->b),&(w->b),&t0);   // wb = (xa+xb)(ya+yb) -(xa.ya) -(xb.yb) +i(xc.yc)
+        FP16_YYY_norm(&z3);
+        FP16_YYY_times_i(&z3);				// i[(xb+xc)(yb+yc) -(xb.yb) - (xc.yc)]					= i(xb.yc + xc.yb)
+        FP16_YYY_add(&(w->a),&z0,&z3);		// wa = xa.ya + i(xb.yc + xc.yb)
+    }
+    else
+    {
+        if (w->type==AMCL_AMCL_FP_SPARSER)
+        {
+            FP48_YYY_smul(w,y);
+            return;
+        }
+// dense by sparser - 13m
+#if SEXTIC_TWIST_ZZZ == D_TYPE
+        FP16_YYY_copy(&z3,&(w->b));
+        FP16_YYY_mul(&z0,&(w->a),&(y->a));
 
-		FP16_YYY_mul(&(w->b),&(w->b),&t1);
-		FP16_YYY_add(&z3,&z3,&(w->c));
-		FP16_YYY_norm(&z3);
-		FP16_YYY_pmul(&z3,&z3,&(y->b).a);
-		FP16_YYY_neg(&t0,&z0);
-		FP16_YYY_neg(&t1,&z2);
+        FP16_YYY_pmul(&z2,&(w->b),&(y->b).a);
+        FP16_YYY_add(&(w->b),&(w->a),&(w->b));
+        FP16_YYY_copy(&t1,&(y->a));
+        FP8_YYY_add(&t1.a,&t1.a,&(y->b).a);
 
-		FP16_YYY_add(&(w->b),&(w->b),&t0);   // z1=z1-z0
-		FP16_YYY_add(&(w->b),&(w->b),&t1);   // z1=z1-z2
+        FP16_YYY_norm(&t1);
+        FP16_YYY_norm(&(w->b));
 
-		FP16_YYY_add(&z3,&z3,&t1);        // z3=z3-z2
-		FP16_YYY_add(&z2,&z2,&t0);        // z2=z2-z0
+        FP16_YYY_mul(&(w->b),&(w->b),&t1);
+        FP16_YYY_add(&z3,&z3,&(w->c));
+        FP16_YYY_norm(&z3);
+        FP16_YYY_pmul(&z3,&z3,&(y->b).a);
+        FP16_YYY_neg(&t0,&z0);
+        FP16_YYY_neg(&t1,&z2);
 
-		FP16_YYY_add(&t0,&(w->a),&(w->c));
-		FP16_YYY_norm(&t0);
-		FP16_YYY_norm(&z3);
+        FP16_YYY_add(&(w->b),&(w->b),&t0);   // z1=z1-z0
+        FP16_YYY_add(&(w->b),&(w->b),&t1);   // z1=z1-z2
 
-		FP16_YYY_mul(&t0,&(y->a),&t0);
-		FP16_YYY_add(&(w->c),&z2,&t0);
+        FP16_YYY_add(&z3,&z3,&t1);        // z3=z3-z2
+        FP16_YYY_add(&z2,&z2,&t0);        // z2=z2-z0
 
-		FP16_YYY_times_i(&z3);
-		FP16_YYY_add(&(w->a),&z0,&z3);
+        FP16_YYY_add(&t0,&(w->a),&(w->c));
+        FP16_YYY_norm(&t0);
+        FP16_YYY_norm(&z3);
+
+        FP16_YYY_mul(&t0,&(y->a),&t0);
+        FP16_YYY_add(&(w->c),&z2,&t0);
+
+        FP16_YYY_times_i(&z3);
+        FP16_YYY_add(&(w->a),&z0,&z3);
 #endif
 #if SEXTIC_TWIST_ZZZ == M_TYPE
-		FP16_YYY_mul(&z0,&(w->a),&(y->a));
-		FP16_YYY_add(&t0,&(w->a),&(w->b));
-		FP16_YYY_norm(&t0);
+        FP16_YYY_mul(&z0,&(w->a),&(y->a));
+        FP16_YYY_add(&t0,&(w->a),&(w->b));
+        FP16_YYY_norm(&t0);
 
-		FP16_YYY_mul(&z1,&t0,&(y->a));
-		FP16_YYY_add(&t0,&(w->b),&(w->c));
-		FP16_YYY_norm(&t0);
+        FP16_YYY_mul(&z1,&t0,&(y->a));
+        FP16_YYY_add(&t0,&(w->b),&(w->c));
+        FP16_YYY_norm(&t0);
 
-		FP16_YYY_pmul(&z3,&t0,&(y->c).b);
-		FP16_YYY_times_i(&z3);
+        FP16_YYY_pmul(&z3,&t0,&(y->c).b);
+        FP16_YYY_times_i(&z3);
 
-		FP16_YYY_neg(&t0,&z0);
-		FP16_YYY_add(&z1,&z1,&t0);   // z1=z1-z0
+        FP16_YYY_neg(&t0,&z0);
+        FP16_YYY_add(&z1,&z1,&t0);   // z1=z1-z0
 
-		FP16_YYY_copy(&(w->b),&z1);
-		FP16_YYY_copy(&z2,&t0);
+        FP16_YYY_copy(&(w->b),&z1);
+        FP16_YYY_copy(&z2,&t0);
 
-		FP16_YYY_add(&t0,&(w->a),&(w->c));
-		FP16_YYY_add(&t1,&(y->a),&(y->c));
+        FP16_YYY_add(&t0,&(w->a),&(w->c));
+        FP16_YYY_add(&t1,&(y->a),&(y->c));
 
-		FP16_YYY_norm(&t0);
-		FP16_YYY_norm(&t1);
+        FP16_YYY_norm(&t0);
+        FP16_YYY_norm(&t1);
 
-		FP16_YYY_mul(&t0,&t1,&t0);
-		FP16_YYY_add(&z2,&z2,&t0);
+        FP16_YYY_mul(&t0,&t1,&t0);
+        FP16_YYY_add(&z2,&z2,&t0);
 
-		FP16_YYY_pmul(&t0,&(w->c),&(y->c).b);
-		FP16_YYY_times_i(&t0);
-		FP16_YYY_neg(&t1,&t0);
-		FP16_YYY_times_i(&t0);
+        FP16_YYY_pmul(&t0,&(w->c),&(y->c).b);
+        FP16_YYY_times_i(&t0);
+        FP16_YYY_neg(&t1,&t0);
+        FP16_YYY_times_i(&t0);
 
-		FP16_YYY_add(&(w->c),&z2,&t1);
-		FP16_YYY_add(&z3,&z3,&t1);
+        FP16_YYY_add(&(w->c),&z2,&t1);
+        FP16_YYY_add(&z3,&z3,&t1);
 
-		FP16_YYY_add(&(w->b),&(w->b),&t0);
-		FP16_YYY_norm(&z3);
-		FP16_YYY_times_i(&z3);
-		FP16_YYY_add(&(w->a),&z0,&z3);
+        FP16_YYY_add(&(w->b),&(w->b),&t0);
+        FP16_YYY_norm(&z3);
+        FP16_YYY_times_i(&z3);
+        FP16_YYY_add(&(w->a),&z0,&z3);
 #endif
-	}
-	w->type=FP_DENSE;
+    }
+    w->type=AMCL_FP_DENSE;
     FP48_YYY_norm(w);
 }
 
 /* FP48 multiplication w=w*y */
 /* catering for special case that arises from special form of ATE pairing line function */
-/* w and y are both sparser line functions - cost = 6m */ 
+/* w and y are both sparser line functions - cost = 6m */
 void FP48_YYY_smul(FP48_YYY *w,FP48_YYY *y)
 {
-	FP8_YYY w1,w2,w3,ta,tb,tc,td,te,t;
+    FP8_YYY w1,w2,w3,ta,tb,tc,td,te,t;
 
 
 #if SEXTIC_TWIST_ZZZ == D_TYPE
-	FP8_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
-	FP8_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
-	FP8_YYY_mul(&w3,&(w->b).a,&(y->b).a); // C1.C2
+    FP8_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
+    FP8_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
+    FP8_YYY_mul(&w3,&(w->b).a,&(y->b).a); // C1.C2
 
-	FP8_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
-	FP8_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
-	FP8_YYY_norm(&ta);
-	FP8_YYY_norm(&tb);
-	FP8_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
-	FP8_YYY_add(&t,&w1,&w2);
-	FP8_YYY_neg(&t,&t);
-	FP8_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)		
-				
-	FP8_YYY_add(&ta,&(w->a).a,&(w->b).a); // A1+C1
-	FP8_YYY_add(&tb,&(y->a).a,&(y->b).a); // A2+C2
-	FP8_YYY_norm(&ta);
-	FP8_YYY_norm(&tb);
-	FP8_YYY_mul(&td,&ta,&tb);			// (A1+C1)(A2+C2)
-	FP8_YYY_add(&t,&w1,&w3);
-	FP8_YYY_neg(&t,&t);
-	FP8_YYY_add(&td,&td,&t);			// (A1+C1)(A2+C2)-A1.A2-C1*C2 =  (A1.C2+A2.C1)		
+    FP8_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
+    FP8_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
+    FP8_YYY_norm(&ta);
+    FP8_YYY_norm(&tb);
+    FP8_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
+    FP8_YYY_add(&t,&w1,&w2);
+    FP8_YYY_neg(&t,&t);
+    FP8_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)
 
-	FP8_YYY_add(&ta,&(w->a).b,&(w->b).a); // B1+C1
-	FP8_YYY_add(&tb,&(y->a).b,&(y->b).a); // B2+C2
-	FP8_YYY_norm(&ta);
-	FP8_YYY_norm(&tb);
-	FP8_YYY_mul(&te,&ta,&tb);			// (B1+C1)(B2+C2)
-	FP8_YYY_add(&t,&w2,&w3);
-	FP8_YYY_neg(&t,&t);
-	FP8_YYY_add(&te,&te,&t);			// (B1+C1)(B2+C2)-B1.B2-C1*C2 =  (B1.C2+B2.C1)		
+    FP8_YYY_add(&ta,&(w->a).a,&(w->b).a); // A1+C1
+    FP8_YYY_add(&tb,&(y->a).a,&(y->b).a); // A2+C2
+    FP8_YYY_norm(&ta);
+    FP8_YYY_norm(&tb);
+    FP8_YYY_mul(&td,&ta,&tb);			// (A1+C1)(A2+C2)
+    FP8_YYY_add(&t,&w1,&w3);
+    FP8_YYY_neg(&t,&t);
+    FP8_YYY_add(&td,&td,&t);			// (A1+C1)(A2+C2)-A1.A2-C1*C2 =  (A1.C2+A2.C1)
 
-	FP8_YYY_times_i(&w2);
-	FP8_YYY_add(&w1,&w1,&w2);
-	FP16_YYY_from_FP8s(&(w->a),&w1,&tc);
-	FP16_YYY_from_FP8s(&(w->b),&td,&te); // only norm these 2
-	FP16_YYY_from_FP8(&(w->c),&w3);
+    FP8_YYY_add(&ta,&(w->a).b,&(w->b).a); // B1+C1
+    FP8_YYY_add(&tb,&(y->a).b,&(y->b).a); // B2+C2
+    FP8_YYY_norm(&ta);
+    FP8_YYY_norm(&tb);
+    FP8_YYY_mul(&te,&ta,&tb);			// (B1+C1)(B2+C2)
+    FP8_YYY_add(&t,&w2,&w3);
+    FP8_YYY_neg(&t,&t);
+    FP8_YYY_add(&te,&te,&t);			// (B1+C1)(B2+C2)-B1.B2-C1*C2 =  (B1.C2+B2.C1)
 
-	FP16_YYY_norm(&(w->a));
-	FP16_YYY_norm(&(w->b));
+    FP8_YYY_times_i(&w2);
+    FP8_YYY_add(&w1,&w1,&w2);
+    FP16_YYY_from_FP8s(&(w->a),&w1,&tc);
+    FP16_YYY_from_FP8s(&(w->b),&td,&te); // only norm these 2
+    FP16_YYY_from_FP8(&(w->c),&w3);
+
+    FP16_YYY_norm(&(w->a));
+    FP16_YYY_norm(&(w->b));
 #endif
 #if SEXTIC_TWIST_ZZZ == M_TYPE
-	FP8_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
-	FP8_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
-	FP8_YYY_mul(&w3,&(w->c).b,&(y->c).b); // F1.F2
+    FP8_YYY_mul(&w1,&(w->a).a,&(y->a).a); // A1.A2
+    FP8_YYY_mul(&w2,&(w->a).b,&(y->a).b); // B1.B2
+    FP8_YYY_mul(&w3,&(w->c).b,&(y->c).b); // F1.F2
 
-	FP8_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
-	FP8_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
-	FP8_YYY_norm(&ta);
-	FP8_YYY_norm(&tb);
-	FP8_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
-	FP8_YYY_add(&t,&w1,&w2);
-	FP8_YYY_neg(&t,&t);
-	FP8_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)		
-				
-	FP8_YYY_add(&ta,&(w->a).a,&(w->c).b); // A1+F1
-	FP8_YYY_add(&tb,&(y->a).a,&(y->c).b); // A2+F2
-	FP8_YYY_norm(&ta);
-	FP8_YYY_norm(&tb);
-	FP8_YYY_mul(&td,&ta,&tb);			// (A1+F1)(A2+F2)
-	FP8_YYY_add(&t,&w1,&w3);
-	FP8_YYY_neg(&t,&t);
-	FP8_YYY_add(&td,&td,&t);			// (A1+F1)(A2+F2)-A1.A2-F1*F2 =  (A1.F2+A2.F1)		
+    FP8_YYY_add(&ta,&(w->a).a,&(w->a).b); // A1+B1
+    FP8_YYY_add(&tb,&(y->a).a,&(y->a).b); // A2+B2
+    FP8_YYY_norm(&ta);
+    FP8_YYY_norm(&tb);
+    FP8_YYY_mul(&tc,&ta,&tb);			// (A1+B1)(A2+B2)
+    FP8_YYY_add(&t,&w1,&w2);
+    FP8_YYY_neg(&t,&t);
+    FP8_YYY_add(&tc,&tc,&t);			// (A1+B1)(A2+B2)-A1.A2-B1*B2 =  (A1.B2+A2.B1)
 
-	FP8_YYY_add(&ta,&(w->a).b,&(w->c).b); // B1+F1
-	FP8_YYY_add(&tb,&(y->a).b,&(y->c).b); // B2+F2
-	FP8_YYY_norm(&ta);
-	FP8_YYY_norm(&tb);
-	FP8_YYY_mul(&te,&ta,&tb);			// (B1+F1)(B2+F2)
-	FP8_YYY_add(&t,&w2,&w3);
-	FP8_YYY_neg(&t,&t);
-	FP8_YYY_add(&te,&te,&t);			// (B1+F1)(B2+F2)-B1.B2-F1*F2 =  (B1.F2+B2.F1)	
+    FP8_YYY_add(&ta,&(w->a).a,&(w->c).b); // A1+F1
+    FP8_YYY_add(&tb,&(y->a).a,&(y->c).b); // A2+F2
+    FP8_YYY_norm(&ta);
+    FP8_YYY_norm(&tb);
+    FP8_YYY_mul(&td,&ta,&tb);			// (A1+F1)(A2+F2)
+    FP8_YYY_add(&t,&w1,&w3);
+    FP8_YYY_neg(&t,&t);
+    FP8_YYY_add(&td,&td,&t);			// (A1+F1)(A2+F2)-A1.A2-F1*F2 =  (A1.F2+A2.F1)
 
-	FP8_YYY_times_i(&w2);
-	FP8_YYY_add(&w1,&w1,&w2);
-	FP16_YYY_from_FP8s(&(w->a),&w1,&tc);
+    FP8_YYY_add(&ta,&(w->a).b,&(w->c).b); // B1+F1
+    FP8_YYY_add(&tb,&(y->a).b,&(y->c).b); // B2+F2
+    FP8_YYY_norm(&ta);
+    FP8_YYY_norm(&tb);
+    FP8_YYY_mul(&te,&ta,&tb);			// (B1+F1)(B2+F2)
+    FP8_YYY_add(&t,&w2,&w3);
+    FP8_YYY_neg(&t,&t);
+    FP8_YYY_add(&te,&te,&t);			// (B1+F1)(B2+F2)-B1.B2-F1*F2 =  (B1.F2+B2.F1)
 
-	FP8_YYY_times_i(&w3);
-	FP8_YYY_norm(&w3);
-	FP16_YYY_from_FP8H(&(w->b),&w3);
+    FP8_YYY_times_i(&w2);
+    FP8_YYY_add(&w1,&w1,&w2);
+    FP16_YYY_from_FP8s(&(w->a),&w1,&tc);
 
-	FP8_YYY_norm(&te);
-	FP8_YYY_times_i(&te);
-	FP16_YYY_from_FP8s(&(w->c),&te,&td);
+    FP8_YYY_times_i(&w3);
+    FP8_YYY_norm(&w3);
+    FP16_YYY_from_FP8H(&(w->b),&w3);
 
-	FP16_YYY_norm(&(w->a));
-	FP16_YYY_norm(&(w->c));
+    FP8_YYY_norm(&te);
+    FP8_YYY_times_i(&te);
+    FP16_YYY_from_FP8s(&(w->c),&te,&td);
+
+    FP16_YYY_norm(&(w->a));
+    FP16_YYY_norm(&(w->c));
 #endif
 
-	w->type=FP_SPARSE;
+    w->type=AMCL_FP_SPARSE;
 }
 
 
@@ -580,18 +582,18 @@
     FP16_YYY_mul(&f1,&(x->b),&(x->c));
     FP16_YYY_times_i(&f1);
     FP16_YYY_sub(&f0,&f0,&f1);  /* y.a */
-	FP16_YYY_norm(&f0); 		
+    FP16_YYY_norm(&f0);
 
     FP16_YYY_sqr(&f1,&(x->c));
     FP16_YYY_times_i(&f1);
     FP16_YYY_mul(&f2,&(x->a),&(x->b));
     FP16_YYY_sub(&f1,&f1,&f2);  /* y.b */
-	FP16_YYY_norm(&f1); 
+    FP16_YYY_norm(&f1);
 
     FP16_YYY_sqr(&f2,&(x->b));
     FP16_YYY_mul(&f3,&(x->a),&(x->c));
     FP16_YYY_sub(&f2,&f2,&f3);  /* y.c */
-	FP16_YYY_norm(&f2); 
+    FP16_YYY_norm(&f2);
 
     FP16_YYY_mul(&f3,&(x->b),&f2);
     FP16_YYY_times_i(&f3);
@@ -601,13 +603,13 @@
     FP16_YYY_times_i(&(w->c));
 
     FP16_YYY_add(&f3,&(w->c),&f3);
-	FP16_YYY_norm(&f3);
-	
+    FP16_YYY_norm(&f3);
+
     FP16_YYY_inv(&f3,&f3);
     FP16_YYY_mul(&(w->a),&f0,&f3);
     FP16_YYY_mul(&(w->b),&f1,&f3);
     FP16_YYY_mul(&(w->c),&f2,&f3);
-	w->type=FP_DENSE;
+    w->type=AMCL_FP_DENSE;
 }
 
 /* constant time powering by small integer of max length bts */
@@ -634,9 +636,9 @@
 void FP48_YYY_compow(FP16_YYY *c,FP48_YYY *x,BIG_XXX e,BIG_XXX r)
 {
     FP48_YYY g1,g2;
-	FP16_YYY cp,cpm1,cpm2;
+    FP16_YYY cp,cpm1,cpm2;
     FP2_YYY  f;
-	BIG_XXX q,a,b,m;
+    BIG_XXX q,a,b,m;
 
     BIG_XXX_rcopy(a,Fra_YYY);
     BIG_XXX_rcopy(b,Frb_YYY);
@@ -645,7 +647,7 @@
     BIG_XXX_rcopy(q,Modulus_YYY);
 
     FP48_YYY_copy(&g1,x);
-	FP48_YYY_copy(&g2,x);
+    FP48_YYY_copy(&g2,x);
 
     BIG_XXX_copy(m,q);
     BIG_XXX_mod(m,r);
@@ -658,11 +660,11 @@
 
     FP48_YYY_trace(c,&g1);
 
-	if (BIG_XXX_iszilch(b))
-	{
-		FP16_YYY_xtr_pow(c,c,e);
-		return;
-	}
+    if (BIG_XXX_iszilch(b))
+    {
+        FP16_YYY_xtr_pow(c,c,e);
+        return;
+    }
 
     FP48_YYY_frob(&g2,&f,1);
     FP48_YYY_trace(&cp,&g2);
@@ -684,32 +686,32 @@
     FP48_YYY w,sf;
     BIG_XXX b1,b3;
     int i,nb,bt;
-	BIG_XXX_copy(b1,b);
+    BIG_XXX_copy(b1,b);
     BIG_XXX_norm(b1);
-	BIG_XXX_pmul(b3,b1,3);
-	BIG_XXX_norm(b3);
+    BIG_XXX_pmul(b3,b1,3);
+    BIG_XXX_norm(b3);
 
-	FP48_YYY_copy(&sf,a);
-	FP48_YYY_norm(&sf);
+    FP48_YYY_copy(&sf,a);
+    FP48_YYY_norm(&sf);
     FP48_YYY_copy(&w,&sf);
 
-	nb=BIG_XXX_nbits(b3);
-	for (i=nb-2;i>=1;i--)
-	{
-		FP48_YYY_usqr(&w,&w);
-		bt=BIG_XXX_bit(b3,i)-BIG_XXX_bit(b1,i);
-		if (bt==1)
-			FP48_YYY_mul(&w,&sf);
-		if (bt==-1)
-		{
-			FP48_YYY_conj(&sf,&sf);
-			FP48_YYY_mul(&w,&sf);
-			FP48_YYY_conj(&sf,&sf);
-		}
-	}
+    nb=BIG_XXX_nbits(b3);
+    for (i=nb-2; i>=1; i--)
+    {
+        FP48_YYY_usqr(&w,&w);
+        bt=BIG_XXX_bit(b3,i)-BIG_XXX_bit(b1,i);
+        if (bt==1)
+            FP48_YYY_mul(&w,&sf);
+        if (bt==-1)
+        {
+            FP48_YYY_conj(&sf,&sf);
+            FP48_YYY_mul(&w,&sf);
+            FP48_YYY_conj(&sf,&sf);
+        }
+    }
 
-	FP48_YYY_copy(r,&w);
-	FP48_YYY_reduce(r);
+    FP48_YYY_copy(r,&w);
+    FP48_YYY_reduce(r);
 }
 
 /* p=q0^u0.q1^u1.q2^u2.q3^u3... */
@@ -720,8 +722,8 @@
 void FP48_YYY_pow16(FP48_YYY *p,FP48_YYY *q,BIG_XXX u[16])
 {
     int i,j,k,nb,pb1,pb2,pb3,pb4,bt;
-	FP48_YYY g1[8],g2[8],g3[8],g4[8],r;
-	BIG_XXX t[16],mt;
+    FP48_YYY g1[8],g2[8],g3[8],g4[8],r;
+    BIG_XXX t[16],mt;
     sign8 w1[NLEN_XXX*BASEBITS_XXX+1];
     sign8 s1[NLEN_XXX*BASEBITS_XXX+1];
     sign8 w2[NLEN_XXX*BASEBITS_XXX+1];
@@ -731,7 +733,7 @@
     sign8 w4[NLEN_XXX*BASEBITS_XXX+1];
     sign8 s4[NLEN_XXX*BASEBITS_XXX+1];
     FP_YYY fx,fy;
-	FP2_YYY  X;
+    FP2_YYY  X;
 
     FP_YYY_rcopy(&fx,Fra_YYY);
     FP_YYY_rcopy(&fy,Frb_YYY);
@@ -743,50 +745,50 @@
 // Precomputed table
     FP48_YYY_copy(&g1[0],&q[0]); // q[0]
     FP48_YYY_copy(&g1[1],&g1[0]);
-	FP48_YYY_mul(&g1[1],&q[1]);	// q[0].q[1]
+    FP48_YYY_mul(&g1[1],&q[1]);	// q[0].q[1]
     FP48_YYY_copy(&g1[2],&g1[0]);
-	FP48_YYY_mul(&g1[2],&q[2]);	// q[0].q[2]
-	FP48_YYY_copy(&g1[3],&g1[1]);
-	FP48_YYY_mul(&g1[3],&q[2]);	// q[0].q[1].q[2]
-	FP48_YYY_copy(&g1[4],&g1[0]);
-	FP48_YYY_mul(&g1[4],&q[3]);  // q[0].q[3]
-	FP48_YYY_copy(&g1[5],&g1[1]);
-	FP48_YYY_mul(&g1[5],&q[3]);	// q[0].q[1].q[3]
-	FP48_YYY_copy(&g1[6],&g1[2]);
-	FP48_YYY_mul(&g1[6],&q[3]);	// q[0].q[2].q[3]
-	FP48_YYY_copy(&g1[7],&g1[3]);
-	FP48_YYY_mul(&g1[7],&q[3]);	// q[0].q[1].q[2].q[3]
+    FP48_YYY_mul(&g1[2],&q[2]);	// q[0].q[2]
+    FP48_YYY_copy(&g1[3],&g1[1]);
+    FP48_YYY_mul(&g1[3],&q[2]);	// q[0].q[1].q[2]
+    FP48_YYY_copy(&g1[4],&g1[0]);
+    FP48_YYY_mul(&g1[4],&q[3]);  // q[0].q[3]
+    FP48_YYY_copy(&g1[5],&g1[1]);
+    FP48_YYY_mul(&g1[5],&q[3]);	// q[0].q[1].q[3]
+    FP48_YYY_copy(&g1[6],&g1[2]);
+    FP48_YYY_mul(&g1[6],&q[3]);	// q[0].q[2].q[3]
+    FP48_YYY_copy(&g1[7],&g1[3]);
+    FP48_YYY_mul(&g1[7],&q[3]);	// q[0].q[1].q[2].q[3]
 
 // Use Frobenius
 
-	for (i=0;i<8;i++)
-	{
-		FP48_YYY_copy(&g2[i],&g1[i]);
-		FP48_YYY_frob(&g2[i],&X,4);
+    for (i=0; i<8; i++)
+    {
+        FP48_YYY_copy(&g2[i],&g1[i]);
+        FP48_YYY_frob(&g2[i],&X,4);
 
-		FP48_YYY_copy(&g3[i],&g2[i]);
-		FP48_YYY_frob(&g3[i],&X,4);
+        FP48_YYY_copy(&g3[i],&g2[i]);
+        FP48_YYY_frob(&g3[i],&X,4);
 
-		FP48_YYY_copy(&g4[i],&g3[i]);
-		FP48_YYY_frob(&g4[i],&X,4);
-	}
+        FP48_YYY_copy(&g4[i],&g3[i]);
+        FP48_YYY_frob(&g4[i],&X,4);
+    }
 
 // Make them odd
-	pb1=1-BIG_XXX_parity(t[0]);
-	BIG_XXX_inc(t[0],pb1);
-	BIG_XXX_norm(t[0]);
+    pb1=1-BIG_XXX_parity(t[0]);
+    BIG_XXX_inc(t[0],pb1);
+    BIG_XXX_norm(t[0]);
 
-	pb2=1-BIG_XXX_parity(t[4]);
-	BIG_XXX_inc(t[4],pb2);
-	BIG_XXX_norm(t[4]);
+    pb2=1-BIG_XXX_parity(t[4]);
+    BIG_XXX_inc(t[4],pb2);
+    BIG_XXX_norm(t[4]);
 
-	pb3=1-BIG_XXX_parity(t[8]);
-	BIG_XXX_inc(t[8],pb3);
-	BIG_XXX_norm(t[8]);
+    pb3=1-BIG_XXX_parity(t[8]);
+    BIG_XXX_inc(t[8],pb3);
+    BIG_XXX_norm(t[8]);
 
-	pb4=1-BIG_XXX_parity(t[12]);
-	BIG_XXX_inc(t[12],pb4);
-	BIG_XXX_norm(t[12]);
+    pb4=1-BIG_XXX_parity(t[12]);
+    BIG_XXX_inc(t[12],pb4);
+    BIG_XXX_norm(t[12]);
 
 // Number of bits
     BIG_XXX_zero(mt);
@@ -796,90 +798,90 @@
     }
     nb=1+BIG_XXX_nbits(mt);
 
-// Sign pivot 
-	s1[nb-1]=1;
-	s2[nb-1]=1;
-	s3[nb-1]=1;
-	s4[nb-1]=1;
-	for (i=0;i<nb-1;i++)
-	{
+// Sign pivot
+    s1[nb-1]=1;
+    s2[nb-1]=1;
+    s3[nb-1]=1;
+    s4[nb-1]=1;
+    for (i=0; i<nb-1; i++)
+    {
         BIG_XXX_fshr(t[0],1);
-		s1[i]=2*BIG_XXX_parity(t[0])-1;
+        s1[i]=2*BIG_XXX_parity(t[0])-1;
         BIG_XXX_fshr(t[4],1);
-		s2[i]=2*BIG_XXX_parity(t[4])-1;
+        s2[i]=2*BIG_XXX_parity(t[4])-1;
         BIG_XXX_fshr(t[8],1);
-		s3[i]=2*BIG_XXX_parity(t[8])-1;
+        s3[i]=2*BIG_XXX_parity(t[8])-1;
         BIG_XXX_fshr(t[12],1);
-		s4[i]=2*BIG_XXX_parity(t[12])-1;
-	}
+        s4[i]=2*BIG_XXX_parity(t[12])-1;
+    }
 
 // Recoded exponents
     for (i=0; i<nb; i++)
     {
-		w1[i]=0;
-		k=1;
-		for (j=1; j<4; j++)
-		{
-			bt=s1[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w1[i]=0;
+        k=1;
+        for (j=1; j<4; j++)
+        {
+            bt=s1[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w1[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w1[i]+=bt*k;
+            k*=2;
         }
 
-		w2[i]=0;
-		k=1;
-		for (j=5; j<8; j++)
-		{
-			bt=s2[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w2[i]=0;
+        k=1;
+        for (j=5; j<8; j++)
+        {
+            bt=s2[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w2[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w2[i]+=bt*k;
+            k*=2;
         }
 
-		w3[i]=0;
-		k=1;
-		for (j=9; j<12; j++)
-		{
-			bt=s3[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w3[i]=0;
+        k=1;
+        for (j=9; j<12; j++)
+        {
+            bt=s3[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w3[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w3[i]+=bt*k;
+            k*=2;
         }
 
-		w4[i]=0;
-		k=1;
-		for (j=13; j<16; j++)
-		{
-			bt=s4[i]*BIG_XXX_parity(t[j]);
-			BIG_XXX_fshr(t[j],1);
+        w4[i]=0;
+        k=1;
+        for (j=13; j<16; j++)
+        {
+            bt=s4[i]*BIG_XXX_parity(t[j]);
+            BIG_XXX_fshr(t[j],1);
 
-			BIG_XXX_dec(t[j],(bt>>1));
-			BIG_XXX_norm(t[j]);
-			w4[i]+=bt*k;
-			k*=2;
+            BIG_XXX_dec(t[j],(bt>>1));
+            BIG_XXX_norm(t[j]);
+            w4[i]+=bt*k;
+            k*=2;
         }
-    }	
+    }
 
 // Main loop
-	FP48_YYY_select(p,g1,2*w1[nb-1]+1);
-	FP48_YYY_select(&r,g2,2*w2[nb-1]+1);
-	FP48_YYY_mul(p,&r);
-	FP48_YYY_select(&r,g3,2*w3[nb-1]+1);
-	FP48_YYY_mul(p,&r);
-	FP48_YYY_select(&r,g4,2*w4[nb-1]+1);
-	FP48_YYY_mul(p,&r);
+    FP48_YYY_select(p,g1,2*w1[nb-1]+1);
+    FP48_YYY_select(&r,g2,2*w2[nb-1]+1);
+    FP48_YYY_mul(p,&r);
+    FP48_YYY_select(&r,g3,2*w3[nb-1]+1);
+    FP48_YYY_mul(p,&r);
+    FP48_YYY_select(&r,g4,2*w4[nb-1]+1);
+    FP48_YYY_mul(p,&r);
     for (i=nb-2; i>=0; i--)
     {
-		FP48_YYY_usqr(p,p);
+        FP48_YYY_usqr(p,p);
         FP48_YYY_select(&r,g1,2*w1[i]+s1[i]);
         FP48_YYY_mul(p,&r);
         FP48_YYY_select(&r,g2,2*w2[i]+s2[i]);
@@ -891,49 +893,52 @@
     }
 
 // apply correction
-	FP48_YYY_conj(&r,&q[0]);   
-	FP48_YYY_mul(&r,p);
-	FP48_YYY_cmove(p,&r,pb1);
-	FP48_YYY_conj(&r,&q[4]);   
-	FP48_YYY_mul(&r,p);
-	FP48_YYY_cmove(p,&r,pb2);
+    FP48_YYY_conj(&r,&q[0]);
+    FP48_YYY_mul(&r,p);
+    FP48_YYY_cmove(p,&r,pb1);
+    FP48_YYY_conj(&r,&q[4]);
+    FP48_YYY_mul(&r,p);
+    FP48_YYY_cmove(p,&r,pb2);
 
-	FP48_YYY_conj(&r,&q[8]);   
-	FP48_YYY_mul(&r,p);
-	FP48_YYY_cmove(p,&r,pb3);
-	FP48_YYY_conj(&r,&q[12]);   
-	FP48_YYY_mul(&r,p);
-	FP48_YYY_cmove(p,&r,pb4);
+    FP48_YYY_conj(&r,&q[8]);
+    FP48_YYY_mul(&r,p);
+    FP48_YYY_cmove(p,&r,pb3);
+    FP48_YYY_conj(&r,&q[12]);
+    FP48_YYY_mul(&r,p);
+    FP48_YYY_cmove(p,&r,pb4);
 
-	FP48_YYY_reduce(p);
+    FP48_YYY_reduce(p);
 }
 
 /* Set w=w^p using Frobenius */
 /* SU= 160 */
 void FP48_YYY_frob(FP48_YYY *w,FP2_YYY  *f,int n)
 {
-	int i;
-	FP8_YYY X2,X4;
-	FP4_YYY F;
+    int i;
     FP2_YYY  f3,f2;				// f=(1+i)^(p-19)/24
-    FP2_YYY_sqr(&f2,f);     // 
+    FP2_YYY_sqr(&f2,f);     //
     FP2_YYY_mul(&f3,&f2,f); // f3=f^3=(1+i)^(p-19)/8
 
-	FP2_YYY_mul_ip(&f3);
-	FP2_YYY_norm(&f3);
-	FP2_YYY_mul_ip(&f3);    // f3 = (1+i)^16/8.(1+i)^(p-19)/8 = (1+i)^(p-3)/8 
-	FP2_YYY_norm(&f3);
+    FP2_YYY_mul_ip(&f3);
+    FP2_YYY_norm(&f3);
+    FP2_YYY_mul_ip(&f3);    // f3 = (1+i)^16/8.(1+i)^(p-19)/8 = (1+i)^(p-3)/8
+    FP2_YYY_norm(&f3);
 
-	for (i=0;i<n;i++)
-	{
-		FP16_YYY_frob(&(w->a),&f3);   // a=a^p
-		FP16_YYY_frob(&(w->b),&f3);   // b=b^p
-		FP16_YYY_frob(&(w->c),&f3);   // c=c^p
-  
-		FP16_YYY_qmul(&(w->b),&(w->b),f); FP16_YYY_times_i4(&(w->b)); FP16_YYY_times_i2(&(w->b)); 
-		FP16_YYY_qmul(&(w->c),&(w->c),&f2); FP16_YYY_times_i4(&(w->c)); FP16_YYY_times_i4(&(w->c)); FP16_YYY_times_i4(&(w->c)); 
-	}
-	w->type=FP_DENSE;
+    for (i=0; i<n; i++)
+    {
+        FP16_YYY_frob(&(w->a),&f3);   // a=a^p
+        FP16_YYY_frob(&(w->b),&f3);   // b=b^p
+        FP16_YYY_frob(&(w->c),&f3);   // c=c^p
+
+        FP16_YYY_qmul(&(w->b),&(w->b),f);
+        FP16_YYY_times_i4(&(w->b));
+        FP16_YYY_times_i2(&(w->b));
+        FP16_YYY_qmul(&(w->c),&(w->c),&f2);
+        FP16_YYY_times_i4(&(w->c));
+        FP16_YYY_times_i4(&(w->c));
+        FP16_YYY_times_i4(&(w->c));
+    }
+    w->type=AMCL_FP_DENSE;
 }
 
 /* SU= 8 */
@@ -985,10 +990,10 @@
     BIG_XXX_toBytes(&(W->val[0]),a);
     FP_YYY_redc(a,&(g->a.a.a.a.b));
     BIG_XXX_toBytes(&(W->val[MODBYTES_XXX]),a);
-    
-	FP_YYY_redc(a,&(g->a.a.a.b.a));
+
+    FP_YYY_redc(a,&(g->a.a.a.b.a));
     BIG_XXX_toBytes(&(W->val[2*MODBYTES_XXX]),a);
-	FP_YYY_redc(a,&(g->a.a.a.b.b));
+    FP_YYY_redc(a,&(g->a.a.a.b.b));
     BIG_XXX_toBytes(&(W->val[3*MODBYTES_XXX]),a);
 
     FP_YYY_redc(a,&(g->a.a.b.a.a));
@@ -1106,7 +1111,7 @@
 /* Restore g from octet string w */
 void FP48_YYY_fromOctet(FP48_YYY *g,octet *W)
 {
-	BIG_XXX b;
+    BIG_XXX b;
 
     BIG_XXX_fromBytes(b,&W->val[0]);
     FP_YYY_nres(&(g->a.a.a.a.a),b);
@@ -1236,6 +1241,6 @@
     FP16_YYY_cmove(&(f->a),&(g->a),d);
     FP16_YYY_cmove(&(f->b),&(g->b),d);
     FP16_YYY_cmove(&(f->c),&(g->c),d);
-	d=~(d-1);
-	f->type^=(f->type^g->type)&d;
+    d=~(d-1);
+    f->type^=(f->type^g->type)&d;
 }
diff --git a/version3/c/fp48.h b/version3/c/fp48.h
index f445af7..93dc50d 100644
--- a/version3/c/fp48.h
+++ b/version3/c/fp48.h
@@ -12,7 +12,7 @@
     FP16_YYY a; /**< first part of FP12 */
     FP16_YYY b; /**< second part of FP12 */
     FP16_YYY c; /**< third part of FP12 */
-	int type;
+    int type;
 } FP48_YYY;
 
 extern const BIG_XXX Fra_YYY; /**< real part of BN curve Frobenius Constant */
@@ -133,7 +133,7 @@
  */
 extern void FP48_YYY_pinpow(FP48_YYY *x,int i,int b);
 
-/**	@brief Raises an FP48 instance x to a BIG_XXX power, compressed to FP16 
+/**	@brief Raises an FP48 instance x to a BIG_XXX power, compressed to FP16
  *
 	@param c FP16 instance, on exit = x^(e mod r) as FP16
 	@param x FP48 input
diff --git a/version3/c/fp8.c b/version3/c/fp8.c
index 3786a7a..9fe0452 100644
--- a/version3/c/fp8.c
+++ b/version3/c/fp8.c
@@ -100,14 +100,14 @@
 {
     /* Just one field neg */
     FP4_YYY m,t;
-	FP8_YYY_norm(x);
+    FP8_YYY_norm(x);
     FP4_YYY_add(&m,&(x->a),&(x->b));
-	FP4_YYY_norm(&m);
+    FP4_YYY_norm(&m);
     FP4_YYY_neg(&m,&m);
     FP4_YYY_add(&t,&m,&(x->b));
     FP4_YYY_add(&(w->b),&m,&(x->a));
     FP4_YYY_copy(&(w->a),&t);
-	FP8_YYY_norm(w);
+    FP8_YYY_norm(w);
 }
 
 /* Set w=conj(x) */
@@ -115,7 +115,7 @@
 {
     FP4_YYY_copy(&(w->a), &(x->a));
     FP4_YYY_neg(&(w->b), &(x->b));
-	FP8_YYY_norm(w);
+    FP8_YYY_norm(w);
 }
 
 /* Set w=-conj(x) */
@@ -123,7 +123,7 @@
 {
     FP4_YYY_copy(&(w->b),&(x->b));
     FP4_YYY_neg(&(w->a), &(x->a));
-	FP8_YYY_norm(w);
+    FP8_YYY_norm(w);
 }
 
 /* Set w=x+y */
@@ -199,8 +199,8 @@
 
     FP4_YYY_add(&t2,&(x->a),&t2);
 
-	FP4_YYY_norm(&t1);  // 2
-	FP4_YYY_norm(&t2);  // 2
+    FP4_YYY_norm(&t1);  // 2
+    FP4_YYY_norm(&t2);  // 2
 
     FP4_YYY_mul(&(w->a),&t1,&t2);
 
@@ -209,7 +209,7 @@
 
     FP4_YYY_add(&t2,&t2,&t3);
 
-	FP4_YYY_norm(&t2);  // 2
+    FP4_YYY_norm(&t2);  // 2
     FP4_YYY_neg(&t2,&t2);
     FP4_YYY_add(&(w->a),&(w->a),&t2);  /* a=(a+b)(a+i^2.b)-i^2.ab-ab = a*a+ib*ib */
     FP4_YYY_add(&(w->b),&t3,&t3);  /* b=2ab */
@@ -223,23 +223,23 @@
 {
 
     FP4_YYY t1,t2,t3,t4;
-    FP4_YYY_mul(&t1,&(x->a),&(y->a)); 
-    FP4_YYY_mul(&t2,&(x->b),&(y->b)); 
+    FP4_YYY_mul(&t1,&(x->a),&(y->a));
+    FP4_YYY_mul(&t2,&(x->b),&(y->b));
 
     FP4_YYY_add(&t3,&(y->b),&(y->a));
     FP4_YYY_add(&t4,&(x->b),&(x->a));
 
-	FP4_YYY_norm(&t4); // 2
-	FP4_YYY_norm(&t3); // 2
+    FP4_YYY_norm(&t4); // 2
+    FP4_YYY_norm(&t3); // 2
 
     FP4_YYY_mul(&t4,&t4,&t3); /* (xa+xb)(ya+yb) */
 
-	FP4_YYY_neg(&t3,&t1);  // 1
-	FP4_YYY_add(&t4,&t4,&t3);  //t4E=3
+    FP4_YYY_neg(&t3,&t1);  // 1
+    FP4_YYY_add(&t4,&t4,&t3);  //t4E=3
     FP4_YYY_norm(&t4);
 
-	FP4_YYY_neg(&t3,&t2);  // 1
-	FP4_YYY_add(&(w->b),&t4,&t3); //wbE=3
+    FP4_YYY_neg(&t3,&t2);  // 1
+    FP4_YYY_add(&(w->b),&t4,&t3); //wbE=3
 
     FP4_YYY_times_i(&t2);
     FP4_YYY_add(&(w->a),&t2,&t1);
@@ -273,47 +273,48 @@
     FP4_YYY_sqr(&t1,&(x->a));
     FP4_YYY_sqr(&t2,&(x->b));
     FP4_YYY_times_i(&t2);
-	FP4_YYY_norm(&t2);
+    FP4_YYY_norm(&t2);
 
     FP4_YYY_sub(&t1,&t1,&t2);
-	FP4_YYY_norm(&t1);
+    FP4_YYY_norm(&t1);
     FP4_YYY_inv(&t1,&t1);
 
     FP4_YYY_mul(&(w->a),&t1,&(x->a));
     FP4_YYY_neg(&t1,&t1);
-	FP4_YYY_norm(&t1);
+    FP4_YYY_norm(&t1);
     FP4_YYY_mul(&(w->b),&t1,&(x->b));
 }
 
 /* w*=i where i = sqrt(sqrt(-1+sqrt(-1))) */
 void FP8_YYY_times_i(FP8_YYY *w)
 {
-	FP4_YYY s,t;
-	FP4_YYY_copy(&s,&(w->b));
-	FP4_YYY_copy(&t,&(w->a));
-	FP4_YYY_times_i(&s);
-	FP4_YYY_copy(&(w->a),&s);
-	FP4_YYY_copy(&(w->b),&t);
-	FP8_YYY_norm(w);
+    FP4_YYY s,t;
+    FP4_YYY_copy(&s,&(w->b));
+    FP4_YYY_copy(&t,&(w->a));
+    FP4_YYY_times_i(&s);
+    FP4_YYY_copy(&(w->a),&s);
+    FP4_YYY_copy(&(w->b),&t);
+    FP8_YYY_norm(w);
 }
 
 void FP8_YYY_times_i2(FP8_YYY *w)
 {
-	FP4_YYY_times_i(&(w->a));
-	FP4_YYY_times_i(&(w->b));
+    FP4_YYY_times_i(&(w->a));
+    FP4_YYY_times_i(&(w->b));
 }
 
 /* Set w=w^p using Frobenius */
 void FP8_YYY_frob(FP8_YYY *w,FP2_YYY *f)
-{ // f=(i+1)^(p-3)/4
-	FP2_YYY ff;
-	FP2_YYY_sqr(&ff,f);  // (i+1)^(p-3)/2
-	FP2_YYY_mul_ip(&ff); // (i+1)^(p-1)/2
-	FP2_YYY_norm(&ff);
-	FP4_YYY_frob(&(w->a),&ff);
-	FP4_YYY_frob(&(w->b),&ff);
-	FP4_YYY_pmul(&(w->b),&(w->b),f);  // times (1+i)^(p-3)/4
-	FP4_YYY_times_i(&(w->b));		// (i+1)^(p-1)/4
+{
+    // f=(i+1)^(p-3)/4
+    FP2_YYY ff;
+    FP2_YYY_sqr(&ff,f);  // (i+1)^(p-3)/2
+    FP2_YYY_mul_ip(&ff); // (i+1)^(p-1)/2
+    FP2_YYY_norm(&ff);
+    FP4_YYY_frob(&(w->a),&ff);
+    FP4_YYY_frob(&(w->b),&ff);
+    FP4_YYY_pmul(&(w->b),&(w->b),f);  // times (1+i)^(p-3)/4
+    FP4_YYY_times_i(&(w->b));		// (i+1)^(p-1)/4
 }
 
 /* Set r=a^b mod m */
@@ -327,7 +328,7 @@
 
     BIG_XXX_copy(z,b);
     FP8_YYY_copy(&w,a);
-	FP8_YYY_norm(&w);
+    FP8_YYY_norm(&w);
     FP8_YYY_one(r);
     BIG_XXX_norm(z);
     while(1)
@@ -350,10 +351,10 @@
 
     FP8_YYY_copy(r,x);
     FP8_YYY_sub(&t1,w,y);
-	FP8_YYY_norm(&t1);
+    FP8_YYY_norm(&t1);
     FP8_YYY_pmul(&t1,&t1,&(r->a));
     FP8_YYY_add(&t2,w,y);
-	FP8_YYY_norm(&t2);
+    FP8_YYY_norm(&t2);
     FP8_YYY_pmul(&t2,&t2,&(r->b));
     FP8_YYY_times_i(&t2);
 
@@ -371,7 +372,7 @@
     FP8_YYY_conj(&w,r);
     FP8_YYY_add(&w,&w,&w);
     FP8_YYY_sqr(r,r);
-	FP8_YYY_norm(&w);
+    FP8_YYY_norm(&w);
     FP8_YYY_sub(r,r,&w);
     FP8_YYY_reduce(r);    /* reduce here as multiple calls trigger automatic reductions */
 }
@@ -382,18 +383,18 @@
     int i,par,nb;
     BIG_XXX v;
     FP2_YYY w2;
-	FP4_YYY w4;
+    FP4_YYY w4;
     FP8_YYY t,a,b,c,sf;
 
     BIG_XXX_zero(v);
     BIG_XXX_inc(v,3);
-	BIG_XXX_norm(v);
+    BIG_XXX_norm(v);
     FP2_YYY_from_BIG(&w2,v);
     FP4_YYY_from_FP2(&w4,&w2);
     FP8_YYY_from_FP4(&a,&w4);
-	FP8_YYY_copy(&sf,x);
-	FP8_YYY_norm(&sf);
-	FP8_YYY_copy(&b,&sf);
+    FP8_YYY_copy(&sf,x);
+    FP8_YYY_norm(&sf);
+    FP8_YYY_copy(&b,&sf);
     FP8_YYY_xtr_D(&c,&sf);
 
     par=BIG_XXX_parity(n);
@@ -444,7 +445,7 @@
     BIG_XXX_copy(e,a);
     BIG_XXX_copy(d,b);
     BIG_XXX_norm(e);
-	BIG_XXX_norm(d);
+    BIG_XXX_norm(d);
     FP8_YYY_copy(&cu,ck);
     FP8_YYY_copy(&cv,cl);
     FP8_YYY_copy(&cumv,ckml);
@@ -584,93 +585,93 @@
 /* returns true if x is QR */
 int FP8_YYY_sqrt(FP8_YYY *r,FP8_YYY* x)
 {
-	FP4_YYY a,s,t;
+    FP4_YYY a,s,t;
 
-	FP8_YYY_copy(r,x);
-	if (FP8_YYY_iszilch(x))
-		return 1;
-	
-	FP4_YYY_copy(&a,&(x->a));
-	FP4_YYY_copy(&s,&(x->b));
+    FP8_YYY_copy(r,x);
+    if (FP8_YYY_iszilch(x))
+        return 1;
 
-	if (FP4_YYY_iszilch(&s))
-	{
-		if (FP4_YYY_sqrt(&t,&a))
-		{
-			FP8_YYY_from_FP4(r,&t);
-		}
-		else
-		{
-			FP4_YYY_div_i(&a);
-			FP4_YYY_sqrt(&t,&a);
-			FP8_YYY_from_FP4H(r,&t);
-		}
-		return 1;
-	}
+    FP4_YYY_copy(&a,&(x->a));
+    FP4_YYY_copy(&s,&(x->b));
 
-	FP4_YYY_sqr(&s,&s);  // s*=s
-	FP4_YYY_sqr(&a,&a);  // a*=a
-	FP4_YYY_times_i(&s);
-	FP4_YYY_norm(&s);
-	FP4_YYY_sub(&a,&a,&s); // a-=txx(s)
+    if (FP4_YYY_iszilch(&s))
+    {
+        if (FP4_YYY_sqrt(&t,&a))
+        {
+            FP8_YYY_from_FP4(r,&t);
+        }
+        else
+        {
+            FP4_YYY_div_i(&a);
+            FP4_YYY_sqrt(&t,&a);
+            FP8_YYY_from_FP4H(r,&t);
+        }
+        return 1;
+    }
 
-	if (!FP4_YYY_sqrt(&s,&a)) return 0;
+    FP4_YYY_sqr(&s,&s);  // s*=s
+    FP4_YYY_sqr(&a,&a);  // a*=a
+    FP4_YYY_times_i(&s);
+    FP4_YYY_norm(&s);
+    FP4_YYY_sub(&a,&a,&s); // a-=txx(s)
 
-	FP4_YYY_sqr(&t,&s);
+    if (!FP4_YYY_sqrt(&s,&a)) return 0;
+
+    FP4_YYY_sqr(&t,&s);
 
 
-	FP4_YYY_copy(&t,&(x->a));
-	FP4_YYY_add(&a,&t,&s);
-	FP4_YYY_norm(&a);
-	FP4_YYY_div2(&a,&a);
+    FP4_YYY_copy(&t,&(x->a));
+    FP4_YYY_add(&a,&t,&s);
+    FP4_YYY_norm(&a);
+    FP4_YYY_div2(&a,&a);
 
-	if (!FP4_YYY_sqrt(&a,&a))
-	{
-		FP4_YYY_sub(&a,&t,&s);
-		FP4_YYY_norm(&a);
-		FP4_YYY_div2(&a,&a);
-		if (!FP4_YYY_sqrt(&a,&a)) return 0;
-	}
+    if (!FP4_YYY_sqrt(&a,&a))
+    {
+        FP4_YYY_sub(&a,&t,&s);
+        FP4_YYY_norm(&a);
+        FP4_YYY_div2(&a,&a);
+        if (!FP4_YYY_sqrt(&a,&a)) return 0;
+    }
 
-	FP4_YYY_copy(&t,&(x->b));
-	FP4_YYY_add(&s,&a,&a);
-	FP4_YYY_inv(&s,&s);
+    FP4_YYY_copy(&t,&(x->b));
+    FP4_YYY_add(&s,&a,&a);
+    FP4_YYY_inv(&s,&s);
 
-	FP4_YYY_mul(&t,&t,&s);
-	FP8_YYY_from_FP4s(r,&a,&t);
+    FP4_YYY_mul(&t,&t,&s);
+    FP8_YYY_from_FP4s(r,&a,&t);
 
-	return 1;
+    return 1;
 
 }
 
 
 void FP8_YYY_div_i(FP8_YYY *f)
 {
-	FP4_YYY u,v;
-	FP4_YYY_copy(&u,&(f->a));
-	FP4_YYY_copy(&v,&(f->b));
-	FP4_YYY_div_i(&u);
-	FP4_YYY_copy(&(f->a),&v);
-	FP4_YYY_copy(&(f->b),&u);
+    FP4_YYY u,v;
+    FP4_YYY_copy(&u,&(f->a));
+    FP4_YYY_copy(&v,&(f->b));
+    FP4_YYY_div_i(&u);
+    FP4_YYY_copy(&(f->a),&v);
+    FP4_YYY_copy(&(f->b),&u);
 }
 
 void FP8_YYY_div_i2(FP8_YYY *f)
 {
-	FP4_YYY_div_i(&(f->a));
-	FP4_YYY_div_i(&(f->b));
+    FP4_YYY_div_i(&(f->a));
+    FP4_YYY_div_i(&(f->b));
 }
 
 
 void FP8_YYY_div_2i(FP8_YYY *f)
 {
-	FP4_YYY u,v;
-	FP4_YYY_copy(&u,&(f->a));
-	FP4_YYY_copy(&v,&(f->b));
-	FP4_YYY_div_2i(&u);
-	FP4_YYY_add(&v,&v,&v);
-	FP4_YYY_norm(&v);
-	FP4_YYY_copy(&(f->a),&v);
-	FP4_YYY_copy(&(f->b),&u);
+    FP4_YYY u,v;
+    FP4_YYY_copy(&u,&(f->a));
+    FP4_YYY_copy(&v,&(f->b));
+    FP4_YYY_div_2i(&u);
+    FP4_YYY_add(&v,&v,&v);
+    FP4_YYY_norm(&v);
+    FP4_YYY_copy(&(f->a),&v);
+    FP4_YYY_copy(&(f->b),&u);
 }
 
 #endif
diff --git a/version3/c/mpin.c b/version3/c/mpin.c
index 9d5d983..6c6ccdd 100644
--- a/version3/c/mpin.c
+++ b/version3/c/mpin.c
@@ -137,7 +137,7 @@
         if (su<0) su=-su;
         su%=2;
         map(&W,u,su);
-        ECP_ZZZ_sub(&P,&W); 
+        ECP_ZZZ_sub(&P,&W);
 
         rn=unmap(v,&sv,&P);
         m=RAND_byte(RNG);
@@ -169,7 +169,7 @@
         sv=(D->val[0]>>1)&1;
         map(&W,u,su);
         map(&P,v,sv);
-        ECP_ZZZ_add(&P,&W); 
+        ECP_ZZZ_add(&P,&W);
         ECP_ZZZ_toOctet(D,&P,false);
     }
 
@@ -188,7 +188,7 @@
     }
     if (res==0)
     {
-        ECP_ZZZ_add(&P,&T); 
+        ECP_ZZZ_add(&P,&T);
         ECP_ZZZ_toOctet(R,&P,false);
     }
     return res;
@@ -203,7 +203,7 @@
     if (!ECP2_ZZZ_fromOctet(&T,W2)) res=MPIN_INVALID_POINT;
     if (res==0)
     {
-        ECP2_ZZZ_add(&Q,&T); 
+        ECP2_ZZZ_add(&Q,&T);
         ECP2_ZZZ_toOctet(W,&Q);
     }
     return res;
@@ -246,7 +246,7 @@
         ECP_ZZZ_mapit(&R,&H);
 
         ECP_ZZZ_pinmul(&R,factor,facbits);
-        ECP_ZZZ_sub(&P,&R); 
+        ECP_ZZZ_sub(&P,&R);
 
         ECP_ZZZ_toOctet(TOKEN,&P,false);
     }
@@ -268,7 +268,7 @@
         ECP_ZZZ_mapit(&R,&H);
 
         ECP_ZZZ_pinmul(&R,factor,facbits);
-        ECP_ZZZ_add(&P,&R); 
+        ECP_ZZZ_add(&P,&R);
 
         ECP_ZZZ_toOctet(TOKEN,&P,false);
     }
@@ -436,7 +436,7 @@
                 PAIR_ZZZ_G1mul(&P,x);				// P=x.H(ID)
                 ECP_ZZZ_toOctet(xID,&P,false);  // xID
                 PAIR_ZZZ_G1mul(&W,x);               // W=x.H(T|ID)
-                ECP_ZZZ_add(&P,&W); 
+                ECP_ZZZ_add(&P,&W);
             }
             else
             {
@@ -456,9 +456,9 @@
     }
 
     if (res==0)
-	{
+    {
         ECP_ZZZ_toOctet(SEC,&T,false);  // V
-	}
+    }
     return res;
 }
 
@@ -471,7 +471,7 @@
 
     BIG_XXX_rcopy(r,CURVE_Order_ZZZ);
 
-	ECP2_ZZZ_generator(&Q);
+    ECP2_ZZZ_generator(&Q);
 
     if (res==0)
     {
@@ -531,7 +531,7 @@
         mhashit(sha,date,&H,&H);
 #endif
         ECP_ZZZ_mapit(&R,&H);
-        ECP_ZZZ_add(&P,&R); 
+        ECP_ZZZ_add(&P,&R);
         ECP_ZZZ_toOctet(HTID,&P,false);
     }
 }
@@ -539,13 +539,13 @@
 /* Implement M-Pin on server side */
 int MPIN_ZZZ_SERVER_2(int date,octet *HID,octet *HTID,octet *Y,octet *SST,octet *xID,octet *xCID,octet *mSEC,octet *E,octet *F,octet *Pa)
 {
-    BIG_XXX px,py,y;
+    BIG_XXX y;
     FP12_YYY g;
     ECP2_ZZZ Q,sQ;
     ECP_ZZZ P,R;
     int res=0;
 
-	ECP2_ZZZ_generator(&Q);
+    ECP2_ZZZ_generator(&Q);
 
     // key-escrow less scheme: use Pa instead of Q in pairing computation
     // Q left for backward compatiblity
@@ -563,11 +563,11 @@
     {
         if (date)
         {
-			if (!ECP_ZZZ_fromOctet(&R,xCID))  res=MPIN_INVALID_POINT;
+            if (!ECP_ZZZ_fromOctet(&R,xCID))  res=MPIN_INVALID_POINT;
         }
         else
         {
-			if (!ECP_ZZZ_fromOctet(&R,xID))  res=MPIN_INVALID_POINT;
+            if (!ECP_ZZZ_fromOctet(&R,xID))  res=MPIN_INVALID_POINT;
         }
     }
     if (res==0)
@@ -723,7 +723,7 @@
         }
         else
         {
-			ECP2_ZZZ_generator(&Q);
+            ECP2_ZZZ_generator(&Q);
         }
     }
     if (res==0)
@@ -921,7 +921,7 @@
 
     BIG_XXX_invmodp(z,z,r);
 
-	ECP2_ZZZ_generator(&Q);
+    ECP2_ZZZ_generator(&Q);
 
     if (res==0)
     {
diff --git a/version3/c/mpin.h b/version3/c/mpin.h
index 98c853c..e0c7227 100644
--- a/version3/c/mpin.h
+++ b/version3/c/mpin.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file mpin.h
+ * @file mpin_ZZZ.h
  * @author Mike Scott
  * @brief M-Pin Header file
  *
diff --git a/version3/c/mpin192.c b/version3/c/mpin192.c
index 92b50ee..9520ddd 100644
--- a/version3/c/mpin192.c
+++ b/version3/c/mpin192.c
@@ -41,7 +41,7 @@
     int hlen=sha;
 
 
-	FP_YYY_redc(x,&(f->a.a.a));
+    FP_YYY_redc(x,&(f->a.a.a));
     BIG_XXX_toBytes(&t[0],x);
     FP_YYY_redc(x,&(f->a.a.b));
     BIG_XXX_toBytes(&t[MODBYTES_XXX],x);
@@ -50,7 +50,7 @@
     FP_YYY_redc(x,&(f->a.b.b));
     BIG_XXX_toBytes(&t[3*MODBYTES_XXX],x);
 
-	FP_YYY_redc(x,&(f->b.a.a));
+    FP_YYY_redc(x,&(f->b.a.a));
     BIG_XXX_toBytes(&t[4*MODBYTES_XXX],x);
     FP_YYY_redc(x,&(f->b.a.b));
     BIG_XXX_toBytes(&t[5*MODBYTES_XXX],x);
@@ -98,9 +98,10 @@
     BIG_XXX_mod(x,q);
 
     while (!ECP_ZZZ_setx(P,x,cb))
-	{
-        BIG_XXX_inc(x,1); BIG_XXX_norm(x);
-	}
+    {
+        BIG_XXX_inc(x,1);
+        BIG_XXX_norm(x);
+    }
 }
 
 /* returns u derived from P. Random value in range 1 to return value should then be added to u */
@@ -113,7 +114,8 @@
     BIG_XXX_copy(u,x);
     do
     {
-        BIG_XXX_dec(u,1); BIG_XXX_norm(u);
+        BIG_XXX_dec(u,1);
+        BIG_XXX_norm(u);
         r++;
     }
     while (!ECP_ZZZ_setx(P,u,s));
@@ -145,7 +147,7 @@
         if (su<0) su=-su;
         su%=2;
         map(&W,u,su);
-        ECP_ZZZ_sub(&P,&W); 
+        ECP_ZZZ_sub(&P,&W);
 
         rn=unmap(v,&sv,&P);
         m=RAND_byte(RNG);
@@ -177,7 +179,7 @@
         sv=(D->val[0]>>1)&1;
         map(&W,u,su);
         map(&P,v,sv);
-        ECP_ZZZ_add(&P,&W); 
+        ECP_ZZZ_add(&P,&W);
         ECP_ZZZ_toOctet(D,&P,false);
     }
 
@@ -196,7 +198,7 @@
     }
     if (res==0)
     {
-        ECP_ZZZ_add(&P,&T); 
+        ECP_ZZZ_add(&P,&T);
         ECP_ZZZ_toOctet(R,&P,false);
     }
     return res;
@@ -211,7 +213,7 @@
     if (!ECP4_ZZZ_fromOctet(&T,W2)) res=MPIN_INVALID_POINT;
     if (res==0)
     {
-        ECP4_ZZZ_add(&Q,&T); 
+        ECP4_ZZZ_add(&Q,&T);
         ECP4_ZZZ_toOctet(W,&Q);
     }
     return res;
@@ -235,8 +237,8 @@
 /* Extract PIN from TOKEN for identity CID */
 int MPIN_ZZZ_EXTRACT_PIN(int sha,octet *CID,int pin,octet *TOKEN)
 {
-	pin%=MAXPIN;
-	return MPIN_ZZZ_EXTRACT_FACTOR(sha,CID,pin,PBLEN,TOKEN);
+    pin%=MAXPIN;
+    return MPIN_ZZZ_EXTRACT_FACTOR(sha,CID,pin,PBLEN,TOKEN);
 }
 
 /* Extract a factor < 32 bits for identity CID */
@@ -254,7 +256,7 @@
         ECP_ZZZ_mapit(&R,&H);
 
         ECP_ZZZ_pinmul(&R,factor,facbits);
-        ECP_ZZZ_sub(&P,&R); 
+        ECP_ZZZ_sub(&P,&R);
 
         ECP_ZZZ_toOctet(TOKEN,&P,false);
     }
@@ -333,10 +335,10 @@
     {
         if (!ECP_ZZZ_fromOctet(&P,G)) res=MPIN_INVALID_POINT;
     }
-    else 
-	{
-		ECP_ZZZ_mapit(&P,G);
-	}
+    else
+    {
+        ECP_ZZZ_mapit(&P,G);
+    }
 
     if (res==0)
     {
@@ -464,9 +466,9 @@
     }
 
     if (res==0)
-	{
+    {
         ECP_ZZZ_toOctet(SEC,&T,false);  // V
-	}
+    }
     return res;
 }
 
@@ -479,7 +481,7 @@
 
     BIG_XXX_rcopy(r,CURVE_Order_ZZZ);
 
-	ECP4_ZZZ_generator(&Q);
+    ECP4_ZZZ_generator(&Q);
 
     if (res==0)
     {
@@ -521,7 +523,6 @@
     char h[MODBYTES_XXX];
     octet H= {0,sizeof(h),h};
     ECP_ZZZ P,R;
-	BIG_XXX x;
 
 #ifdef USE_ANONYMOUS
     ECP_ZZZ_mapit(&P,CID);
@@ -540,7 +541,7 @@
         mhashit(sha,date,&H,&H);
 #endif
         ECP_ZZZ_mapit(&R,&H);
-        ECP_ZZZ_add(&P,&R); 
+        ECP_ZZZ_add(&P,&R);
         ECP_ZZZ_toOctet(HTID,&P,false);
     }
 }
@@ -548,13 +549,13 @@
 /* Implement M-Pin on server side */
 int MPIN_ZZZ_SERVER_2(int date,octet *HID,octet *HTID,octet *Y,octet *SST,octet *xID,octet *xCID,octet *mSEC,octet *E,octet *F,octet *Pa)
 {
-    BIG_XXX px,py,y;
+    BIG_XXX y;
     FP24_YYY g;
     ECP4_ZZZ Q,sQ;
     ECP_ZZZ P,R;
     int res=0;
 
-	ECP4_ZZZ_generator(&Q);
+    ECP4_ZZZ_generator(&Q);
 
     // key-escrow less scheme: use Pa instead of Q in pairing computation
     // Q left for backward compatiblity
@@ -571,13 +572,13 @@
 
     if (res==0)
     {
-       if (date)
+        if (date)
         {
-			if (!ECP_ZZZ_fromOctet(&R,xCID))  res=MPIN_INVALID_POINT;
+            if (!ECP_ZZZ_fromOctet(&R,xCID))  res=MPIN_INVALID_POINT;
         }
         else
         {
-			if (!ECP_ZZZ_fromOctet(&R,xID))  res=MPIN_INVALID_POINT;
+            if (!ECP_ZZZ_fromOctet(&R,xID))  res=MPIN_INVALID_POINT;
         }
     }
     if (res==0)
@@ -720,7 +721,6 @@
     ECP_ZZZ P,T;
     ECP4_ZZZ Q;
     FP24_YYY g;
-	BIG_XXX x;
     int res=0;
 
     if (!ECP_ZZZ_fromOctet(&T,TOKEN)) res=MPIN_INVALID_POINT;
@@ -734,7 +734,7 @@
         }
         else
         {
-			ECP4_ZZZ_generator(&Q);
+            ECP4_ZZZ_generator(&Q);
         }
     }
     if (res==0)
@@ -758,7 +758,7 @@
 int MPIN_ZZZ_CLIENT_KEY(int sha,octet *G1,octet *G2,int pin,octet *R,octet *X,octet *H,octet *wCID,octet *CK)
 {
     FP24_YYY g1,g2;
-	FP8_YYY c;
+    FP8_YYY c;
 
     ECP_ZZZ W;
     int res=0;
@@ -781,10 +781,10 @@
         FP24_YYY_pinpow(&g2,pin,PBLEN);
         FP24_YYY_mul(&g1,&g2);
 
-		PAIR_ZZZ_G1mul(&W,x);
+        PAIR_ZZZ_G1mul(&W,x);
 
-		FP24_YYY_compow(&c,&g1,z,r);
-		mpin_hash(sha,&c,&W,CK);
+        FP24_YYY_compow(&c,&g1,z,r);
+        mpin_hash(sha,&c,&W,CK);
 
     }
     return res;
@@ -870,10 +870,10 @@
         return rtn;
 
     OCT_joctet(&M,pID);
-   if (MESSAGE!=NULL)
-   {
-       OCT_joctet(&M,MESSAGE);
-   }
+    if (MESSAGE!=NULL)
+    {
+        OCT_joctet(&M,MESSAGE);
+    }
 
     MPIN_ZZZ_GET_Y(sha,TimeValue,&M,Y);
 
@@ -900,10 +900,10 @@
     MPIN_ZZZ_SERVER_1(sha,date,ID,HID,HTID);
 
     OCT_joctet(&M,pU);
-   if (MESSAGE!=NULL)
-   {
-       OCT_joctet(&M,MESSAGE);
-   }
+    if (MESSAGE!=NULL)
+    {
+        OCT_joctet(&M,MESSAGE);
+    }
 
     MPIN_ZZZ_GET_Y(sha,TimeValue,&M,Y);
 
@@ -933,7 +933,7 @@
 
     BIG_XXX_invmodp(z,z,r);
 
-	ECP4_ZZZ_generator(&Q);
+    ECP4_ZZZ_generator(&Q);
 
     if (res==0)
     {
@@ -942,4 +942,4 @@
     }
 
     return res;
-}
\ No newline at end of file
+}
diff --git a/version3/c/mpin192.h b/version3/c/mpin192.h
index 79f562c..c457bd2 100644
--- a/version3/c/mpin192.h
+++ b/version3/c/mpin192.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file mpin.h
+ * @file mpin_ZZZ.h
  * @author Mike Scott and Kealan McCusker
  * @date 2nd June 2015
  * @brief M-Pin Header file
diff --git a/version3/c/mpin256.c b/version3/c/mpin256.c
index d8d9ea3..fd91d28 100644
--- a/version3/c/mpin256.c
+++ b/version3/c/mpin256.c
@@ -42,9 +42,9 @@
     char t[18*MODBYTES_XXX];  // to hold 10 BIGs
     int hlen=sha;
 
-	FP_YYY_redc(x,&(f->a.a.a.a));
+    FP_YYY_redc(x,&(f->a.a.a.a));
     BIG_XXX_toBytes(&t[0],x);
-	FP_YYY_redc(x,&(f->a.a.a.b));
+    FP_YYY_redc(x,&(f->a.a.a.b));
     BIG_XXX_toBytes(&t[MODBYTES_XXX],x);
 
     FP_YYY_redc(x,&(f->a.a.b.a));
@@ -62,14 +62,14 @@
     FP_YYY_redc(x,&(f->a.b.b.b));
     BIG_XXX_toBytes(&t[7*MODBYTES_XXX],x);
 
-	FP_YYY_redc(x,&(f->b.a.a.a));
+    FP_YYY_redc(x,&(f->b.a.a.a));
     BIG_XXX_toBytes(&t[8*MODBYTES_XXX],x);
-	FP_YYY_redc(x,&(f->b.a.a.b));
+    FP_YYY_redc(x,&(f->b.a.a.b));
     BIG_XXX_toBytes(&t[9*MODBYTES_XXX],x);
 
     FP_YYY_redc(x,&(f->b.a.b.a));
     BIG_XXX_toBytes(&t[10*MODBYTES_XXX],x);
-	FP_YYY_redc(x,&(f->b.a.b.b));
+    FP_YYY_redc(x,&(f->b.a.b.b));
     BIG_XXX_toBytes(&t[11*MODBYTES_XXX],x);
 
     FP_YYY_redc(x,&(f->b.b.a.a));
@@ -121,9 +121,10 @@
     BIG_XXX_mod(x,q);
 
     while (!ECP_ZZZ_setx(P,x,cb))
-	{
-        BIG_XXX_inc(x,1); BIG_XXX_norm(x);
-	}
+    {
+        BIG_XXX_inc(x,1);
+        BIG_XXX_norm(x);
+    }
 }
 
 /* returns u derived from P. Random value in range 1 to return value should then be added to u */
@@ -136,7 +137,8 @@
     BIG_XXX_copy(u,x);
     do
     {
-        BIG_XXX_dec(u,1); BIG_XXX_norm(u);
+        BIG_XXX_dec(u,1);
+        BIG_XXX_norm(u);
         r++;
     }
     while (!ECP_ZZZ_setx(P,u,s));
@@ -168,7 +170,7 @@
         if (su<0) su=-su;
         su%=2;
         map(&W,u,su);
-        ECP_ZZZ_sub(&P,&W); 
+        ECP_ZZZ_sub(&P,&W);
 
         rn=unmap(v,&sv,&P);
         m=RAND_byte(RNG);
@@ -200,7 +202,7 @@
         sv=(D->val[0]>>1)&1;
         map(&W,u,su);
         map(&P,v,sv);
-        ECP_ZZZ_add(&P,&W); 
+        ECP_ZZZ_add(&P,&W);
         ECP_ZZZ_toOctet(D,&P,false);
     }
 
@@ -219,7 +221,7 @@
     }
     if (res==0)
     {
-        ECP_ZZZ_add(&P,&T); 
+        ECP_ZZZ_add(&P,&T);
         ECP_ZZZ_toOctet(R,&P,false);
     }
     return res;
@@ -234,7 +236,7 @@
     if (!ECP8_ZZZ_fromOctet(&T,W2)) res=MPIN_INVALID_POINT;
     if (res==0)
     {
-        ECP8_ZZZ_add(&Q,&T); 
+        ECP8_ZZZ_add(&Q,&T);
         ECP8_ZZZ_toOctet(W,&Q);
     }
     return res;
@@ -258,8 +260,8 @@
 /* Extract PIN from TOKEN for identity CID */
 int MPIN_ZZZ_EXTRACT_PIN(int sha,octet *CID,int pin,octet *TOKEN)
 {
-	pin%=MAXPIN;
-	return MPIN_ZZZ_EXTRACT_FACTOR(sha,CID,pin,PBLEN,TOKEN);
+    pin%=MAXPIN;
+    return MPIN_ZZZ_EXTRACT_FACTOR(sha,CID,pin,PBLEN,TOKEN);
 }
 
 /* Extract a factor < 32 bits for identity CID */
@@ -277,7 +279,7 @@
         ECP_ZZZ_mapit(&R,&H);
 
         ECP_ZZZ_pinmul(&R,factor,facbits);
-        ECP_ZZZ_sub(&P,&R); 
+        ECP_ZZZ_sub(&P,&R);
 
         ECP_ZZZ_toOctet(TOKEN,&P,false);
     }
@@ -299,7 +301,7 @@
         ECP_ZZZ_mapit(&R,&H);
 
         ECP_ZZZ_pinmul(&R,factor,facbits);
-        ECP_ZZZ_add(&P,&R); 
+        ECP_ZZZ_add(&P,&R);
 
         ECP_ZZZ_toOctet(TOKEN,&P,false);
     }
@@ -356,10 +358,10 @@
     {
         if (!ECP_ZZZ_fromOctet(&P,G)) res=MPIN_INVALID_POINT;
     }
-    else 
-	{
-		ECP_ZZZ_mapit(&P,G);
-	}
+    else
+    {
+        ECP_ZZZ_mapit(&P,G);
+    }
 
     if (res==0)
     {
@@ -467,11 +469,11 @@
                 PAIR_ZZZ_G1mul(&P,x);				// P=x.H(ID)
                 ECP_ZZZ_toOctet(xID,&P,false);  // xID
                 PAIR_ZZZ_G1mul(&W,x);               // W=x.H(T|ID)
-                ECP_ZZZ_add(&P,&W); 
+                ECP_ZZZ_add(&P,&W);
             }
             else
             {
-                ECP_ZZZ_add(&P,&W); 
+                ECP_ZZZ_add(&P,&W);
                 PAIR_ZZZ_G1mul(&P,x);
             }
             if (xCID!=NULL) ECP_ZZZ_toOctet(xCID,&P,false);  // U
@@ -487,9 +489,9 @@
     }
 
     if (res==0)
-	{
+    {
         ECP_ZZZ_toOctet(SEC,&T,false);  // V
-	}
+    }
     return res;
 }
 
@@ -502,7 +504,7 @@
 
     BIG_XXX_rcopy(r,CURVE_Order_ZZZ);
 
-	ECP8_ZZZ_generator(&Q);
+    ECP8_ZZZ_generator(&Q);
 
     if (res==0)
     {
@@ -544,7 +546,6 @@
     char h[MODBYTES_XXX];
     octet H= {0,sizeof(h),h};
     ECP_ZZZ P,R;
-	BIG_XXX x;
 
 #ifdef USE_ANONYMOUS
     ECP_ZZZ_mapit(&P,CID);
@@ -563,7 +564,7 @@
         mhashit(sha,date,&H,&H);
 #endif
         ECP_ZZZ_mapit(&R,&H);
-        ECP_ZZZ_add(&P,&R); 
+        ECP_ZZZ_add(&P,&R);
         ECP_ZZZ_toOctet(HTID,&P,false);
     }
 }
@@ -571,13 +572,13 @@
 /* Implement M-Pin on server side */
 int MPIN_ZZZ_SERVER_2(int date,octet *HID,octet *HTID,octet *Y,octet *SST,octet *xID,octet *xCID,octet *mSEC,octet *E,octet *F,octet *Pa)
 {
-    BIG_XXX px,py,y;
+    BIG_XXX y;
     FP48_YYY g;
     ECP8_ZZZ Q,sQ;
     ECP_ZZZ P,R;
     int res=0;
 
-	ECP8_ZZZ_generator(&Q);
+    ECP8_ZZZ_generator(&Q);
 
     // key-escrow less scheme: use Pa instead of Q in pairing computation
     // Q left for backward compatiblity
@@ -594,13 +595,13 @@
 
     if (res==0)
     {
-       if (date)
+        if (date)
         {
-			if (!ECP_ZZZ_fromOctet(&R,xCID))  res=MPIN_INVALID_POINT;
+            if (!ECP_ZZZ_fromOctet(&R,xCID))  res=MPIN_INVALID_POINT;
         }
         else
         {
-			if (!ECP_ZZZ_fromOctet(&R,xID))  res=MPIN_INVALID_POINT;
+            if (!ECP_ZZZ_fromOctet(&R,xID))  res=MPIN_INVALID_POINT;
         }
     }
     if (res==0)
@@ -742,7 +743,6 @@
     ECP_ZZZ P,T;
     ECP8_ZZZ Q;
     FP48_YYY g;
-	BIG_XXX x;
     int res=0;
 
     if (!ECP_ZZZ_fromOctet(&T,TOKEN)) res=MPIN_INVALID_POINT;
@@ -756,7 +756,7 @@
         }
         else
         {
-			ECP8_ZZZ_generator(&Q);
+            ECP8_ZZZ_generator(&Q);
         }
     }
     if (res==0)
@@ -780,7 +780,7 @@
 int MPIN_ZZZ_CLIENT_KEY(int sha,octet *G1,octet *G2,int pin,octet *R,octet *X,octet *H,octet *wCID,octet *CK)
 {
     FP48_YYY g1,g2;
-	FP16_YYY c;
+    FP16_YYY c;
 
     ECP_ZZZ W;
     int res=0;
@@ -803,10 +803,10 @@
         FP48_YYY_pinpow(&g2,pin,PBLEN);
         FP48_YYY_mul(&g1,&g2);
 
-		PAIR_ZZZ_G1mul(&W,x);
+        PAIR_ZZZ_G1mul(&W,x);
 
-		FP48_YYY_compow(&c,&g1,z,r);
-		mpin_hash(sha,&c,&W,CK);
+        FP48_YYY_compow(&c,&g1,z,r);
+        mpin_hash(sha,&c,&W,CK);
 
     }
     return res;
@@ -892,10 +892,10 @@
         return rtn;
 
     OCT_joctet(&M,pID);
-   if (MESSAGE!=NULL)
-   {
-       OCT_joctet(&M,MESSAGE);
-   }
+    if (MESSAGE!=NULL)
+    {
+        OCT_joctet(&M,MESSAGE);
+    }
 
     MPIN_ZZZ_GET_Y(sha,TimeValue,&M,Y);
 
@@ -922,10 +922,10 @@
     MPIN_ZZZ_SERVER_1(sha,date,ID,HID,HTID);
 
     OCT_joctet(&M,pU);
-   if (MESSAGE!=NULL)
-   {
-       OCT_joctet(&M,MESSAGE);
-   }
+    if (MESSAGE!=NULL)
+    {
+        OCT_joctet(&M,MESSAGE);
+    }
 
     MPIN_ZZZ_GET_Y(sha,TimeValue,&M,Y);
 
@@ -955,7 +955,7 @@
 
     BIG_XXX_invmodp(z,z,r);
 
-	ECP8_ZZZ_generator(&Q);
+    ECP8_ZZZ_generator(&Q);
 
     if (res==0)
     {
diff --git a/version3/c/mpin256.h b/version3/c/mpin256.h
index 46ba21a..3307e57 100644
--- a/version3/c/mpin256.h
+++ b/version3/c/mpin256.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file mpin.h
+ * @file mpin_ZZZ.h
  * @author Mike Scott and Kealan McCusker
  * @date 2nd June 2015
  * @brief M-Pin Header file
diff --git a/version3/c/oct.c b/version3/c/oct.c
index 866c96c..cb9c067 100644
--- a/version3/c/oct.c
+++ b/version3/c/oct.c
@@ -93,7 +93,7 @@
         res|=(int)(x->val[i]^y->val[i]);
     }
     if (res==0) return 1;
-	return 0;
+    return 0;
 }
 
 /* Shift octet to the left by n bytes. Leftmost bytes disappear  */
diff --git a/version3/c/pair.c b/version3/c/pair.c
index 47265fa..8faf54a 100644
--- a/version3/c/pair.c
+++ b/version3/c/pair.c
@@ -131,20 +131,20 @@
     }
 
     FP12_YYY_from_FP4s(v,&a,&b,&c);
-	v->type=FP_SPARSER;
+    v->type=AMCL_AMCL_FP_SPARSER;
 }
 
 
 /* prepare ate parameter, n=6u+2 (BN) or n=u (BLS), n3=3*n */
 int PAIR_ZZZ_nbits(BIG_XXX n3,BIG_XXX n)
 {
-	BIG_XXX x;
+    BIG_XXX x;
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
 
 #if PAIRING_FRIENDLY_ZZZ==BN
     BIG_XXX_pmul(n,x,6);
 #if SIGN_OF_X_ZZZ==POSITIVEX
-	BIG_XXX_inc(n,2);
+    BIG_XXX_inc(n,2);
 #else
     BIG_XXX_dec(n,2);
 #endif
@@ -154,8 +154,8 @@
 #endif
 
     BIG_XXX_norm(n);
-	BIG_XXX_pmul(n3,n,3);
-	BIG_XXX_norm(n3);
+    BIG_XXX_pmul(n3,n,3);
+    BIG_XXX_norm(n3);
 
     return BIG_XXX_nbits(n3);
 }
@@ -172,97 +172,98 @@
 /* prepare for multi-pairing */
 void PAIR_ZZZ_initmp(FP12_YYY r[])
 {
-	int i;
-	for (i=ATE_BITS_ZZZ-1; i>=0; i--)
-		FP12_YYY_one(&r[i]);
-	return;
+    int i;
+    for (i=ATE_BITS_ZZZ-1; i>=0; i--)
+        FP12_YYY_one(&r[i]);
+    return;
 }
 
 /* basic Miller loop */
 void PAIR_ZZZ_miller(FP12_YYY *res,FP12_YYY r[])
 {
-	int i;
+    int i;
     FP12_YYY_one(res);
-	for (i=ATE_BITS_ZZZ-1; i>=1; i--)
-	{
-		FP12_YYY_sqr(res,res);
-		FP12_YYY_ssmul(res,&r[i]);
-	}
+    for (i=ATE_BITS_ZZZ-1; i>=1; i--)
+    {
+        FP12_YYY_sqr(res,res);
+        FP12_YYY_ssmul(res,&r[i]);
+    }
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
     FP12_YYY_conj(res,res);
 #endif
-	FP12_YYY_ssmul(res,&r[0]);
-	return;
+    FP12_YYY_ssmul(res,&r[0]);
+    return;
 }
 
 /* Accumulate another set of line functions for n-pairing */
 void PAIR_ZZZ_another(FP12_YYY r[],ECP2_ZZZ* PV,ECP_ZZZ* QV)
 {
-    int i,j,nb,bt;
-	BIG_XXX x,n,n3;
+    int i,nb,bt;
+    BIG_XXX n,n3;
     FP12_YYY lv,lv2;
     ECP2_ZZZ A,NP,P;
-	ECP_ZZZ Q;
-	FP_YYY Qx,Qy;
+    ECP_ZZZ Q;
+    FP_YYY Qx,Qy;
 #if PAIRING_FRIENDLY_ZZZ==BN
-	ECP2_ZZZ K;
+    ECP2_ZZZ K;
     FP2_YYY X;
     FP_YYY_rcopy(&Qx,Fra_YYY);
     FP_YYY_rcopy(&Qy,Frb_YYY);
     FP2_YYY_from_FPs(&X,&Qx,&Qy);
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-	FP2_YYY_inv(&X,&X);
-	FP2_YYY_norm(&X);
+    FP2_YYY_inv(&X,&X);
+    FP2_YYY_norm(&X);
 #endif
 #endif
 
-	nb=PAIR_ZZZ_nbits(n3,n);
+    nb=PAIR_ZZZ_nbits(n3,n);
 
-	ECP2_ZZZ_copy(&P,PV);
-	ECP_ZZZ_copy(&Q,QV);
+    ECP2_ZZZ_copy(&P,PV);
+    ECP_ZZZ_copy(&Q,QV);
 
-	ECP2_ZZZ_affine(&P);
-	ECP_ZZZ_affine(&Q);
+    ECP2_ZZZ_affine(&P);
+    ECP_ZZZ_affine(&Q);
 
-	FP_YYY_copy(&Qx,&(Q.x));
-	FP_YYY_copy(&Qy,&(Q.y));
+    FP_YYY_copy(&Qx,&(Q.x));
+    FP_YYY_copy(&Qy,&(Q.y));
 
-	ECP2_ZZZ_copy(&A,&P);
-	ECP2_ZZZ_copy(&NP,&P); ECP2_ZZZ_neg(&NP);
+    ECP2_ZZZ_copy(&A,&P);
+    ECP2_ZZZ_copy(&NP,&P);
+    ECP2_ZZZ_neg(&NP);
 
-	for (i=nb-2; i>=1; i--)
-	{
-		PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
+    for (i=nb-2; i>=1; i--)
+    {
+        PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
 
-		bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
-		if (bt==1)
-		{
-			PAIR_ZZZ_line(&lv2,&A,&P,&Qx,&Qy);
-			FP12_YYY_smul(&lv,&lv2);
-		}
-		if (bt==-1)
-		{
-			PAIR_ZZZ_line(&lv2,&A,&NP,&Qx,&Qy);
-			FP12_YYY_smul(&lv,&lv2);
-		}
-		FP12_YYY_ssmul(&r[i],&lv);
-	}
+        bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
+        if (bt==1)
+        {
+            PAIR_ZZZ_line(&lv2,&A,&P,&Qx,&Qy);
+            FP12_YYY_smul(&lv,&lv2);
+        }
+        if (bt==-1)
+        {
+            PAIR_ZZZ_line(&lv2,&A,&NP,&Qx,&Qy);
+            FP12_YYY_smul(&lv,&lv2);
+        }
+        FP12_YYY_ssmul(&r[i],&lv);
+    }
 
 #if PAIRING_FRIENDLY_ZZZ==BN
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	ECP2_ZZZ_neg(&A);
+    ECP2_ZZZ_neg(&A);
 #endif
 
-	ECP2_ZZZ_copy(&K,&P);
-	ECP2_ZZZ_frob(&K,&X);
-	PAIR_ZZZ_line(&lv,&A,&K,&Qx,&Qy);
-	ECP2_ZZZ_frob(&K,&X);
-	ECP2_ZZZ_neg(&K);
-	PAIR_ZZZ_line(&lv2,&A,&K,&Qx,&Qy);
-	FP12_YYY_smul(&lv,&lv2);
-	FP12_YYY_ssmul(&r[0],&lv);
+    ECP2_ZZZ_copy(&K,&P);
+    ECP2_ZZZ_frob(&K,&X);
+    PAIR_ZZZ_line(&lv,&A,&K,&Qx,&Qy);
+    ECP2_ZZZ_frob(&K,&X);
+    ECP2_ZZZ_neg(&K);
+    PAIR_ZZZ_line(&lv2,&A,&K,&Qx,&Qy);
+    FP12_YYY_smul(&lv,&lv2);
+    FP12_YYY_ssmul(&r[0],&lv);
 
 #endif
 }
@@ -270,12 +271,11 @@
 /* Optimal R-ate pairing r=e(P,Q) */
 void PAIR_ZZZ_ate(FP12_YYY *r,ECP2_ZZZ *P1,ECP_ZZZ *Q1)
 {
-
-    BIG_XXX x,n,n3;
+    BIG_XXX n,n3;
     FP_YYY Qx,Qy;
     int i,nb,bt;
     ECP2_ZZZ A,NP,P;
-	ECP_ZZZ Q;
+    ECP_ZZZ Q;
     FP12_YYY lv,lv2;
 #if PAIRING_FRIENDLY_ZZZ==BN
     ECP2_ZZZ KA;
@@ -291,46 +291,47 @@
 #endif
 #endif
 
-	nb=PAIR_ZZZ_nbits(n3,n);
+    nb=PAIR_ZZZ_nbits(n3,n);
 
-	ECP2_ZZZ_copy(&P,P1);
-	ECP_ZZZ_copy(&Q,Q1);
+    ECP2_ZZZ_copy(&P,P1);
+    ECP_ZZZ_copy(&Q,Q1);
 
-	ECP2_ZZZ_affine(&P);
-	ECP_ZZZ_affine(&Q);
+    ECP2_ZZZ_affine(&P);
+    ECP_ZZZ_affine(&Q);
 
     FP_YYY_copy(&Qx,&(Q.x));
     FP_YYY_copy(&Qy,&(Q.y));
 
     ECP2_ZZZ_copy(&A,&P);
-	ECP2_ZZZ_copy(&NP,&P); ECP2_ZZZ_neg(&NP);
+    ECP2_ZZZ_copy(&NP,&P);
+    ECP2_ZZZ_neg(&NP);
 
     FP12_YYY_one(r);
 
     /* Main Miller Loop */
     for (i=nb-2; i>=1; i--)   //0
     {
-		FP12_YYY_sqr(r,r);
+        FP12_YYY_sqr(r,r);
         PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
 
-		bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
+        bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
         if (bt==1)
         {
             PAIR_ZZZ_line(&lv2,&A,&P,&Qx,&Qy);
             FP12_YYY_smul(&lv,&lv2);
         }
-		if (bt==-1)
-		{
+        if (bt==-1)
+        {
             PAIR_ZZZ_line(&lv2,&A,&NP,&Qx,&Qy);
             FP12_YYY_smul(&lv,&lv2);
-		}
-		FP12_YYY_ssmul(r,&lv);
+        }
+        FP12_YYY_ssmul(r,&lv);
 
     }
 
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP12_YYY_conj(r,r);
+    FP12_YYY_conj(r,r);
 #endif
 
     /* R-ate fixup required for BN curves */
@@ -346,7 +347,7 @@
     ECP2_ZZZ_frob(&KA,&X);
     ECP2_ZZZ_neg(&KA);
     PAIR_ZZZ_line(&lv2,&A,&KA,&Qx,&Qy);
-	FP12_YYY_smul(&lv,&lv2);
+    FP12_YYY_smul(&lv,&lv2);
     FP12_YYY_ssmul(r,&lv);
 #endif
 }
@@ -354,11 +355,11 @@
 /* Optimal R-ate double pairing e(P,Q).e(R,S) */
 void PAIR_ZZZ_double_ate(FP12_YYY *r,ECP2_ZZZ *P1,ECP_ZZZ *Q1,ECP2_ZZZ *R1,ECP_ZZZ *S1)
 {
-    BIG_XXX x,n,n3;
+    BIG_XXX n,n3;
     FP_YYY Qx,Qy,Sx,Sy;
     int i,nb,bt;
     ECP2_ZZZ A,B,NP,NR,P,R;
-	ECP_ZZZ Q,S;
+    ECP_ZZZ Q,S;
     FP12_YYY lv,lv2;
 #if PAIRING_FRIENDLY_ZZZ==BN
     FP2_YYY X;
@@ -373,19 +374,19 @@
     FP2_YYY_norm(&X);
 #endif
 #endif
-	nb=PAIR_ZZZ_nbits(n3,n);
+    nb=PAIR_ZZZ_nbits(n3,n);
 
-	ECP2_ZZZ_copy(&P,P1);
-	ECP_ZZZ_copy(&Q,Q1);
+    ECP2_ZZZ_copy(&P,P1);
+    ECP_ZZZ_copy(&Q,Q1);
 
-	ECP2_ZZZ_affine(&P);
-	ECP_ZZZ_affine(&Q);
+    ECP2_ZZZ_affine(&P);
+    ECP_ZZZ_affine(&Q);
 
-	ECP2_ZZZ_copy(&R,R1);
-	ECP_ZZZ_copy(&S,S1);
+    ECP2_ZZZ_copy(&R,R1);
+    ECP_ZZZ_copy(&S,S1);
 
-	ECP2_ZZZ_affine(&R);
-	ECP_ZZZ_affine(&S);
+    ECP2_ZZZ_affine(&R);
+    ECP_ZZZ_affine(&S);
 
     FP_YYY_copy(&Qx,&(Q.x));
     FP_YYY_copy(&Qy,&(Q.y));
@@ -396,8 +397,10 @@
     ECP2_ZZZ_copy(&A,&P);
     ECP2_ZZZ_copy(&B,&R);
 
-	ECP2_ZZZ_copy(&NP,&P); ECP2_ZZZ_neg(&NP);
-	ECP2_ZZZ_copy(&NR,&R); ECP2_ZZZ_neg(&NR);
+    ECP2_ZZZ_copy(&NP,&P);
+    ECP2_ZZZ_neg(&NP);
+    ECP2_ZZZ_copy(&NR,&R);
+    ECP2_ZZZ_neg(&NR);
 
     FP12_YYY_one(r);
 
@@ -407,24 +410,24 @@
         FP12_YYY_sqr(r,r);
         PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
         PAIR_ZZZ_line(&lv2,&B,&B,&Sx,&Sy);
-		FP12_YYY_smul(&lv,&lv2);
+        FP12_YYY_smul(&lv,&lv2);
         FP12_YYY_ssmul(r,&lv);
 
-		bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
+        bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
         if (bt==1)
         {
             PAIR_ZZZ_line(&lv,&A,&P,&Qx,&Qy);
             PAIR_ZZZ_line(&lv2,&B,&R,&Sx,&Sy);
-			FP12_YYY_smul(&lv,&lv2);
+            FP12_YYY_smul(&lv,&lv2);
             FP12_YYY_ssmul(r,&lv);
         }
-		if (bt==-1)
-		{
+        if (bt==-1)
+        {
             PAIR_ZZZ_line(&lv,&A,&NP,&Qx,&Qy);
             PAIR_ZZZ_line(&lv2,&B,&NR,&Sx,&Sy);
-			FP12_YYY_smul(&lv,&lv2);
+            FP12_YYY_smul(&lv,&lv2);
             FP12_YYY_ssmul(r,&lv);
-		}
+        }
 
     }
 
@@ -432,7 +435,7 @@
     /* R-ate fixup required for BN curves */
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP12_YYY_conj(r,r);
+    FP12_YYY_conj(r,r);
 #endif
 
 #if PAIRING_FRIENDLY_ZZZ==BN
@@ -448,7 +451,7 @@
     ECP2_ZZZ_frob(&K,&X);
     ECP2_ZZZ_neg(&K);
     PAIR_ZZZ_line(&lv2,&A,&K,&Qx,&Qy);
-	FP12_YYY_smul(&lv,&lv2);
+    FP12_YYY_smul(&lv,&lv2);
     FP12_YYY_ssmul(r,&lv);
 
     ECP2_ZZZ_copy(&K,&R);
@@ -457,7 +460,7 @@
     ECP2_ZZZ_frob(&K,&X);
     ECP2_ZZZ_neg(&K);
     PAIR_ZZZ_line(&lv2,&B,&K,&Sx,&Sy);
-	FP12_YYY_smul(&lv,&lv2);
+    FP12_YYY_smul(&lv,&lv2);
     FP12_YYY_ssmul(r,&lv);
 #endif
 }
@@ -487,11 +490,11 @@
     FP12_YYY_frob(r,&X);
     FP12_YYY_mul(r,&t0);
 
-	if (FP12_YYY_isunity(r))
-	{
-		FP12_YYY_zero(r);
-		return;
-	}
+    if (FP12_YYY_isunity(r))
+    {
+        FP12_YYY_zero(r);
+        return;
+    }
 
     /* Hard part of final exp - see Duquesne & Ghamman eprint 2015/192.pdf */
 #if PAIRING_FRIENDLY_ZZZ==BN
@@ -724,7 +727,8 @@
     BIG_XXX_rcopy(q,CURVE_Order_ZZZ);
     glv(u,e);
 
-    ECP_ZZZ_copy(&Q,P); ECP_ZZZ_affine(&Q);
+    ECP_ZZZ_copy(&Q,P);
+    ECP_ZZZ_affine(&Q);
     FP_YYY_rcopy(&cru,CURVE_Cru_ZZZ);
     FP_YYY_mul(&(Q.x),&(Q.x),&cru);
 
@@ -795,7 +799,7 @@
             BIG_XXX_copy(u[i],x);
             ECP2_ZZZ_neg(&Q[i]);
         }
-        BIG_XXX_norm(u[i]);    
+        BIG_XXX_norm(u[i]);
     }
 
     ECP2_ZZZ_mul4(P,Q,u);
diff --git a/version3/c/pair.h b/version3/c/pair.h
index f03b329..a7350bd 100644
--- a/version3/c/pair.h
+++ b/version3/c/pair.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file pair.h
+ * @file pair_ZZZ.h
  * @author Mike Scott
  * @brief PAIR Header File
  *
diff --git a/version3/c/pair192.c b/version3/c/pair192.c
index 790a2d7..3e6f966 100644
--- a/version3/c/pair192.c
+++ b/version3/c/pair192.c
@@ -27,124 +27,124 @@
 /* Line function */
 static void PAIR_ZZZ_line(FP24_YYY *v,ECP4_ZZZ *A,ECP4_ZZZ *B,FP_YYY *Qx,FP_YYY *Qy)
 {
-	FP4_YYY X1,Y1,T1,T2;
-	FP4_YYY XX,YY,ZZ,YZ;
+    FP4_YYY X1,Y1,T1,T2;
+    FP4_YYY XX,YY,ZZ,YZ;
     FP8_YYY a,b,c;
 
-	if (A==B)
+    if (A==B)
     {
         /* doubling */
- 		FP4_YYY_copy(&XX,&(A->x));	//FP4_YYY XX=new FP4_YYY(A.getx());  //X
-		FP4_YYY_copy(&YY,&(A->y));	//FP4_YYY YY=new FP4_YYY(A.gety());  //Y
-		FP4_YYY_copy(&ZZ,&(A->z));	//FP4_YYY ZZ=new FP4_YYY(A.getz());  //Z
+        FP4_YYY_copy(&XX,&(A->x));	//FP4_YYY XX=new FP4_YYY(A.getx());  //X
+        FP4_YYY_copy(&YY,&(A->y));	//FP4_YYY YY=new FP4_YYY(A.gety());  //Y
+        FP4_YYY_copy(&ZZ,&(A->z));	//FP4_YYY ZZ=new FP4_YYY(A.getz());  //Z
 
 
-		FP4_YYY_copy(&YZ,&YY);		//FP4_YYY YZ=new FP4_YYY(YY);        //Y 
-		FP4_YYY_mul(&YZ,&YZ,&ZZ);		//YZ.mul(ZZ);                //YZ
-		FP4_YYY_sqr(&XX,&XX);		//XX.sqr();	               //X^2
-		FP4_YYY_sqr(&YY,&YY);		//YY.sqr();	               //Y^2
-		FP4_YYY_sqr(&ZZ,&ZZ);		//ZZ.sqr();			       //Z^2
-			
-		FP4_YYY_imul(&YZ,&YZ,4);	//YZ.imul(4);
-		FP4_YYY_neg(&YZ,&YZ);		//YZ.neg(); 
-		FP4_YYY_norm(&YZ);			//YZ.norm();       //-4YZ
+        FP4_YYY_copy(&YZ,&YY);		//FP4_YYY YZ=new FP4_YYY(YY);        //Y
+        FP4_YYY_mul(&YZ,&YZ,&ZZ);		//YZ.mul(ZZ);                //YZ
+        FP4_YYY_sqr(&XX,&XX);		//XX.sqr();	               //X^2
+        FP4_YYY_sqr(&YY,&YY);		//YY.sqr();	               //Y^2
+        FP4_YYY_sqr(&ZZ,&ZZ);		//ZZ.sqr();			       //Z^2
 
-		FP4_YYY_imul(&XX,&XX,6);					//6X^2
-		FP4_YYY_qmul(&XX,&XX,Qx);	               //6X^2.Xs
+        FP4_YYY_imul(&YZ,&YZ,4);	//YZ.imul(4);
+        FP4_YYY_neg(&YZ,&YZ);		//YZ.neg();
+        FP4_YYY_norm(&YZ);			//YZ.norm();       //-4YZ
 
-		FP4_YYY_imul(&ZZ,&ZZ,3*CURVE_B_I_ZZZ);	//3Bz^2 
+        FP4_YYY_imul(&XX,&XX,6);					//6X^2
+        FP4_YYY_qmul(&XX,&XX,Qx);	               //6X^2.Xs
 
-		FP4_YYY_qmul(&YZ,&YZ,Qy);	//-4YZ.Ys
+        FP4_YYY_imul(&ZZ,&ZZ,3*CURVE_B_I_ZZZ);	//3Bz^2
+
+        FP4_YYY_qmul(&YZ,&YZ,Qy);	//-4YZ.Ys
 
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-		FP4_YYY_div_2i(&ZZ);		//6(b/i)z^2
+        FP4_YYY_div_2i(&ZZ);		//6(b/i)z^2
 #endif
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-		FP4_YYY_times_i(&ZZ);
-		FP4_YYY_add(&ZZ,&ZZ,&ZZ);  // 6biz^2
-		FP4_YYY_times_i(&YZ);
-		FP4_YYY_norm(&YZ);	
+        FP4_YYY_times_i(&ZZ);
+        FP4_YYY_add(&ZZ,&ZZ,&ZZ);  // 6biz^2
+        FP4_YYY_times_i(&YZ);
+        FP4_YYY_norm(&YZ);
 #endif
-		FP4_YYY_norm(&ZZ);			// 6bi.Z^2 
+        FP4_YYY_norm(&ZZ);			// 6bi.Z^2
 
-		FP4_YYY_add(&YY,&YY,&YY);	// 2y^2
-		FP4_YYY_sub(&ZZ,&ZZ,&YY);	// 
-		FP4_YYY_norm(&ZZ);			// 6b.Z^2-2Y^2
+        FP4_YYY_add(&YY,&YY,&YY);	// 2y^2
+        FP4_YYY_sub(&ZZ,&ZZ,&YY);	//
+        FP4_YYY_norm(&ZZ);			// 6b.Z^2-2Y^2
 
-		FP8_YYY_from_FP4s(&a,&YZ,&ZZ); // -4YZ.Ys | 6b.Z^2-2Y^2 | 6X^2.Xs 
+        FP8_YYY_from_FP4s(&a,&YZ,&ZZ); // -4YZ.Ys | 6b.Z^2-2Y^2 | 6X^2.Xs
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-		FP8_YYY_from_FP4(&b,&XX);	
-		FP8_YYY_zero(&c);
+        FP8_YYY_from_FP4(&b,&XX);
+        FP8_YYY_zero(&c);
 #endif
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-		FP8_YYY_zero(&b);
-		FP8_YYY_from_FP4H(&c,&XX);
+        FP8_YYY_zero(&b);
+        FP8_YYY_from_FP4H(&c,&XX);
 #endif
 
-		ECP4_ZZZ_dbl(A);				//A.dbl();
+        ECP4_ZZZ_dbl(A);				//A.dbl();
     }
     else
     {
         /* addition */
 
-		FP4_YYY_copy(&X1,&(A->x));		//FP4_YYY X1=new FP4_YYY(A.getx());    // X1
-		FP4_YYY_copy(&Y1,&(A->y));		//FP4_YYY Y1=new FP4_YYY(A.gety());    // Y1
-		FP4_YYY_copy(&T1,&(A->z));		//FP4_YYY T1=new FP4_YYY(A.getz());    // Z1
-			
-		FP4_YYY_copy(&T2,&T1);		//FP4_YYY T2=new FP4_YYY(A.getz());    // Z1
+        FP4_YYY_copy(&X1,&(A->x));		//FP4_YYY X1=new FP4_YYY(A.getx());    // X1
+        FP4_YYY_copy(&Y1,&(A->y));		//FP4_YYY Y1=new FP4_YYY(A.gety());    // Y1
+        FP4_YYY_copy(&T1,&(A->z));		//FP4_YYY T1=new FP4_YYY(A.getz());    // Z1
 
-		FP4_YYY_mul(&T1,&T1,&(B->y));	//T1.mul(B.gety());    // T1=Z1.Y2 
-		FP4_YYY_mul(&T2,&T2,&(B->x));	//T2.mul(B.getx());    // T2=Z1.X2
+        FP4_YYY_copy(&T2,&T1);		//FP4_YYY T2=new FP4_YYY(A.getz());    // Z1
 
-		FP4_YYY_sub(&X1,&X1,&T2);		//X1.sub(T2); 
-		FP4_YYY_norm(&X1);				//X1.norm();  // X1=X1-Z1.X2
-		FP4_YYY_sub(&Y1,&Y1,&T1);		//Y1.sub(T1); 
-		FP4_YYY_norm(&Y1);				//Y1.norm();  // Y1=Y1-Z1.Y2
+        FP4_YYY_mul(&T1,&T1,&(B->y));	//T1.mul(B.gety());    // T1=Z1.Y2
+        FP4_YYY_mul(&T2,&T2,&(B->x));	//T2.mul(B.getx());    // T2=Z1.X2
 
-		FP4_YYY_copy(&T1,&X1);			//T1.copy(X1);            // T1=X1-Z1.X2
+        FP4_YYY_sub(&X1,&X1,&T2);		//X1.sub(T2);
+        FP4_YYY_norm(&X1);				//X1.norm();  // X1=X1-Z1.X2
+        FP4_YYY_sub(&Y1,&Y1,&T1);		//Y1.sub(T1);
+        FP4_YYY_norm(&Y1);				//Y1.norm();  // Y1=Y1-Z1.Y2
 
-		FP4_YYY_qmul(&X1,&X1,Qy);		//X1.pmul(Qy);            // X1=(X1-Z1.X2).Ys
+        FP4_YYY_copy(&T1,&X1);			//T1.copy(X1);            // T1=X1-Z1.X2
+
+        FP4_YYY_qmul(&X1,&X1,Qy);		//X1.pmul(Qy);            // X1=(X1-Z1.X2).Ys
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-		FP4_YYY_times_i(&X1);
-		FP4_YYY_norm(&X1);
+        FP4_YYY_times_i(&X1);
+        FP4_YYY_norm(&X1);
 #endif
 
-		FP4_YYY_mul(&T1,&T1,&(B->y));	//T1.mul(B.gety());       // T1=(X1-Z1.X2).Y2
+        FP4_YYY_mul(&T1,&T1,&(B->y));	//T1.mul(B.gety());       // T1=(X1-Z1.X2).Y2
 
-		FP4_YYY_copy(&T2,&Y1);			//T2.copy(Y1);            // T2=Y1-Z1.Y2
-		FP4_YYY_mul(&T2,&T2,&(B->x));	//T2.mul(B.getx());       // T2=(Y1-Z1.Y2).X2
-		FP4_YYY_sub(&T2,&T2,&T1);		//T2.sub(T1); 
-		FP4_YYY_norm(&T2);				//T2.norm();          // T2=(Y1-Z1.Y2).X2 - (X1-Z1.X2).Y2
-		FP4_YYY_qmul(&Y1,&Y1,Qx);		//Y1.pmul(Qx);  
-		FP4_YYY_neg(&Y1,&Y1);			//Y1.neg(); 
-		FP4_YYY_norm(&Y1);				//Y1.norm(); // Y1=-(Y1-Z1.Y2).Xs
+        FP4_YYY_copy(&T2,&Y1);			//T2.copy(Y1);            // T2=Y1-Z1.Y2
+        FP4_YYY_mul(&T2,&T2,&(B->x));	//T2.mul(B.getx());       // T2=(Y1-Z1.Y2).X2
+        FP4_YYY_sub(&T2,&T2,&T1);		//T2.sub(T1);
+        FP4_YYY_norm(&T2);				//T2.norm();          // T2=(Y1-Z1.Y2).X2 - (X1-Z1.X2).Y2
+        FP4_YYY_qmul(&Y1,&Y1,Qx);		//Y1.pmul(Qx);
+        FP4_YYY_neg(&Y1,&Y1);			//Y1.neg();
+        FP4_YYY_norm(&Y1);				//Y1.norm(); // Y1=-(Y1-Z1.Y2).Xs
 
-		FP8_YYY_from_FP4s(&a,&X1,&T2);	// (X1-Z1.X2).Ys  |  (Y1-Z1.Y2).X2 - (X1-Z1.X2).Y2  | - (Y1-Z1.Y2).Xs
+        FP8_YYY_from_FP4s(&a,&X1,&T2);	// (X1-Z1.X2).Ys  |  (Y1-Z1.Y2).X2 - (X1-Z1.X2).Y2  | - (Y1-Z1.Y2).Xs
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-		FP8_YYY_from_FP4(&b,&Y1);		//b=new FP4(Y1);
-		FP8_YYY_zero(&c);
+        FP8_YYY_from_FP4(&b,&Y1);		//b=new FP4(Y1);
+        FP8_YYY_zero(&c);
 #endif
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-		FP8_YYY_zero(&b);
-		FP8_YYY_from_FP4H(&c,&Y1);		//b=new FP4(Y1);
+        FP8_YYY_zero(&b);
+        FP8_YYY_from_FP4H(&c,&Y1);		//b=new FP4(Y1);
 #endif
-		ECP4_ZZZ_add(A,B);			//A.add(B);
+        ECP4_ZZZ_add(A,B);			//A.add(B);
     }
 
     FP24_YYY_from_FP8s(v,&a,&b,&c);
-	v->type=FP_SPARSER;
+    v->type=AMCL_AMCL_FP_SPARSER;
 }
 
 /* prepare ate parameter, n=6u+2 (BN) or n=u (BLS), n3=3*n */
 int PAIR_ZZZ_nbits(BIG_XXX n3,BIG_XXX n)
 {
-	BIG_XXX x;
+    BIG_XXX x;
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
 
     BIG_XXX_copy(n,x);
     BIG_XXX_norm(n);
-	BIG_XXX_pmul(n3,n,3);
-	BIG_XXX_norm(n3);
+    BIG_XXX_pmul(n3,n,3);
+    BIG_XXX_norm(n3);
 
     return BIG_XXX_nbits(n3);
 }
@@ -161,117 +161,119 @@
 /* prepare for multi-pairing */
 void PAIR_ZZZ_initmp(FP24_YYY r[])
 {
-	int i;
-	for (i=ATE_BITS_ZZZ-1; i>=0; i--)
-		FP24_YYY_one(&r[i]);
-	return;
+    int i;
+    for (i=ATE_BITS_ZZZ-1; i>=0; i--)
+        FP24_YYY_one(&r[i]);
+    return;
 }
 
 /* basic Miller loop */
 void PAIR_ZZZ_miller(FP24_YYY *res,FP24_YYY r[])
 {
-	int i;
+    int i;
     FP24_YYY_one(res);
-	for (i=ATE_BITS_ZZZ-1; i>=1; i--)
-	{
-		FP24_YYY_sqr(res,res);
-		FP24_YYY_ssmul(res,&r[i]);
-	}
+    for (i=ATE_BITS_ZZZ-1; i>=1; i--)
+    {
+        FP24_YYY_sqr(res,res);
+        FP24_YYY_ssmul(res,&r[i]);
+    }
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
     FP24_YYY_conj(res,res);
 #endif
-	FP24_YYY_ssmul(res,&r[0]);
-	return;
+    FP24_YYY_ssmul(res,&r[0]);
+    return;
 }
 
 /* Accumulate another set of line functions for n-pairing */
 void PAIR_ZZZ_another(FP24_YYY r[],ECP4_ZZZ* PV,ECP_ZZZ* QV)
 {
-    int i,j,nb,bt;
-	BIG_XXX x,n,n3;
+    int i,nb,bt;
+    BIG_XXX n,n3;
     FP24_YYY lv,lv2;
     ECP4_ZZZ A,NP,P;
-	ECP_ZZZ Q;
-	FP_YYY Qx,Qy;
+    ECP_ZZZ Q;
+    FP_YYY Qx,Qy;
 
-	nb=PAIR_ZZZ_nbits(n3,n);
+    nb=PAIR_ZZZ_nbits(n3,n);
 
-	ECP4_ZZZ_copy(&P,PV);
-	ECP_ZZZ_copy(&Q,QV);
+    ECP4_ZZZ_copy(&P,PV);
+    ECP_ZZZ_copy(&Q,QV);
 
-	ECP4_ZZZ_affine(&P);
-	ECP_ZZZ_affine(&Q);
+    ECP4_ZZZ_affine(&P);
+    ECP_ZZZ_affine(&Q);
 
-	FP_YYY_copy(&Qx,&(Q.x));
-	FP_YYY_copy(&Qy,&(Q.y));
+    FP_YYY_copy(&Qx,&(Q.x));
+    FP_YYY_copy(&Qy,&(Q.y));
 
-	ECP4_ZZZ_copy(&A,&P);
-	ECP4_ZZZ_copy(&NP,&P); ECP4_ZZZ_neg(&NP);
+    ECP4_ZZZ_copy(&A,&P);
+    ECP4_ZZZ_copy(&NP,&P);
+    ECP4_ZZZ_neg(&NP);
 
-	for (i=nb-2; i>=1; i--)
-	{
-		PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
+    for (i=nb-2; i>=1; i--)
+    {
+        PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
 
-		bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
-		if (bt==1)
-		{
-			PAIR_ZZZ_line(&lv2,&A,&P,&Qx,&Qy);
-			FP24_YYY_smul(&lv,&lv2);
-		}
-		if (bt==-1)
-		{
-			PAIR_ZZZ_line(&lv2,&A,&NP,&Qx,&Qy);
-			FP24_YYY_smul(&lv,&lv2);
-		}
-		FP24_YYY_ssmul(&r[i],&lv);
-	}
+        bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
+        if (bt==1)
+        {
+            PAIR_ZZZ_line(&lv2,&A,&P,&Qx,&Qy);
+            FP24_YYY_smul(&lv,&lv2);
+        }
+        if (bt==-1)
+        {
+            PAIR_ZZZ_line(&lv2,&A,&NP,&Qx,&Qy);
+            FP24_YYY_smul(&lv,&lv2);
+        }
+        FP24_YYY_ssmul(&r[i],&lv);
+    }
 }
 
 /* Optimal R-ate pairing r=e(P,Q) */
 void PAIR_ZZZ_ate(FP24_YYY *r,ECP4_ZZZ *P1,ECP_ZZZ *Q1)
 {
-    BIG_XXX x,n,n3;
-	FP_YYY Qx,Qy;
+    BIG_XXX n,n3;
+    FP_YYY Qx,Qy;
     int i,nb,bt;
     ECP4_ZZZ A,NP,P;
-	ECP_ZZZ Q;
+    ECP_ZZZ Q;
     FP24_YYY lv,lv2;
 
-	nb=PAIR_ZZZ_nbits(n3,n);
+    nb=PAIR_ZZZ_nbits(n3,n);
 
-	ECP4_ZZZ_copy(&P,P1);
-	ECP_ZZZ_copy(&Q,Q1);
+    ECP4_ZZZ_copy(&P,P1);
+    ECP_ZZZ_copy(&Q,Q1);
 
-	ECP4_ZZZ_affine(&P);
-	ECP_ZZZ_affine(&Q);
+    ECP4_ZZZ_affine(&P);
+    ECP_ZZZ_affine(&Q);
 
 
     FP_YYY_copy(&Qx,&(Q.x));
     FP_YYY_copy(&Qy,&(Q.y));
 
     ECP4_ZZZ_copy(&A,&P);
-	ECP4_ZZZ_copy(&NP,&P); ECP4_ZZZ_neg(&NP);
+    ECP4_ZZZ_copy(&NP,&P);
+    ECP4_ZZZ_neg(&NP);
 
     FP24_YYY_one(r);
 
     /* Main Miller Loop */
     for (i=nb-2; i>=1; i--)
     {
-		FP24_YYY_sqr(r,r);
+        FP24_YYY_sqr(r,r);
         PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
 
-		bt= BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i);  // BIG_bit(n,i); 
+        bt= BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i);  // BIG_bit(n,i);
         if (bt==1)
         {
             PAIR_ZZZ_line(&lv2,&A,&P,&Qx,&Qy);
             FP24_YYY_smul(&lv,&lv2);
         }
-		if (bt==-1)
-		{
+        if (bt==-1)
+        {
             PAIR_ZZZ_line(&lv2,&A,&NP,&Qx,&Qy);
             FP24_YYY_smul(&lv,&lv2);
-		}
+        }
         FP24_YYY_ssmul(r,&lv);
     }
 
@@ -284,25 +286,25 @@
 /* Optimal R-ate double pairing e(P,Q).e(R,S) */
 void PAIR_ZZZ_double_ate(FP24_YYY *r,ECP4_ZZZ *P1,ECP_ZZZ *Q1,ECP4_ZZZ *R1,ECP_ZZZ *S1)
 {
-    BIG_XXX x,n,n3;
-	FP_YYY Qx,Qy,Sx,Sy;
+    BIG_XXX n,n3;
+    FP_YYY Qx,Qy,Sx,Sy;
     int i,nb,bt;
     ECP4_ZZZ A,B,NP,NR,P,R;
-	ECP_ZZZ Q,S;
+    ECP_ZZZ Q,S;
     FP24_YYY lv,lv2;
-	nb=PAIR_ZZZ_nbits(n3,n);
+    nb=PAIR_ZZZ_nbits(n3,n);
 
-	ECP4_ZZZ_copy(&P,P1);
-	ECP_ZZZ_copy(&Q,Q1);
+    ECP4_ZZZ_copy(&P,P1);
+    ECP_ZZZ_copy(&Q,Q1);
 
-	ECP4_ZZZ_affine(&P);
-	ECP_ZZZ_affine(&Q);
+    ECP4_ZZZ_affine(&P);
+    ECP_ZZZ_affine(&Q);
 
-	ECP4_ZZZ_copy(&R,R1);
-	ECP_ZZZ_copy(&S,S1);
+    ECP4_ZZZ_copy(&R,R1);
+    ECP_ZZZ_copy(&S,S1);
 
-	ECP4_ZZZ_affine(&R);
-	ECP_ZZZ_affine(&S);
+    ECP4_ZZZ_affine(&R);
+    ECP_ZZZ_affine(&S);
 
     FP_YYY_copy(&Qx,&(Q.x));
     FP_YYY_copy(&Qy,&(Q.y));
@@ -312,36 +314,38 @@
 
     ECP4_ZZZ_copy(&A,&P);
     ECP4_ZZZ_copy(&B,&R);
-	ECP4_ZZZ_copy(&NP,&P); ECP4_ZZZ_neg(&NP);
-	ECP4_ZZZ_copy(&NR,&R); ECP4_ZZZ_neg(&NR);
+    ECP4_ZZZ_copy(&NP,&P);
+    ECP4_ZZZ_neg(&NP);
+    ECP4_ZZZ_copy(&NR,&R);
+    ECP4_ZZZ_neg(&NR);
 
     FP24_YYY_one(r);
 
     /* Main Miller Loop */
     for (i=nb-2; i>=1; i--)
     {
-		FP24_YYY_sqr(r,r);
+        FP24_YYY_sqr(r,r);
         PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
         PAIR_ZZZ_line(&lv2,&B,&B,&Sx,&Sy);
-		FP24_YYY_smul(&lv,&lv2);
+        FP24_YYY_smul(&lv,&lv2);
         FP24_YYY_ssmul(r,&lv);
 
-		bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
+        bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
         if (bt==1)
         {
             PAIR_ZZZ_line(&lv,&A,&P,&Qx,&Qy);
-			PAIR_ZZZ_line(&lv2,&B,&R,&Sx,&Sy);
+            PAIR_ZZZ_line(&lv2,&B,&R,&Sx,&Sy);
             FP24_YYY_smul(&lv,&lv2);
             FP24_YYY_ssmul(r,&lv);
         }
-		if (bt==-1)
-		{
+        if (bt==-1)
+        {
             PAIR_ZZZ_line(&lv,&A,&NP,&Qx,&Qy);
-			PAIR_ZZZ_line(&lv2,&B,&NR,&Sx,&Sy);
+            PAIR_ZZZ_line(&lv2,&B,&NR,&Sx,&Sy);
             FP24_YYY_smul(&lv,&lv2);
             FP24_YYY_ssmul(r,&lv);
-		}
-	}
+        }
+    }
 
 
 
@@ -357,7 +361,7 @@
 {
     FP2_YYY X;
     BIG_XXX x;
-	FP_YYY a,b;
+    FP_YYY a,b;
     FP24_YYY t0,t1,t2,t3,t4,t5,t6,t7;  // could lose one of these - r=t3
 
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
@@ -377,89 +381,89 @@
 
     FP24_YYY_mul(r,&t0);
 
-	if (FP24_YYY_isunity(r))
-	{
-		FP24_YYY_zero(r);
-		return;
-	}
+    if (FP24_YYY_isunity(r))
+    {
+        FP24_YYY_zero(r);
+        return;
+    }
 // Ghamman & Fouotsa Method - (completely garbled in  https://eprint.iacr.org/2016/130)
 
-	FP24_YYY_usqr(&t7,r);			// t7=f^2
-	FP24_YYY_pow(&t1,&t7,x);		// t1=t7^u
+    FP24_YYY_usqr(&t7,r);			// t7=f^2
+    FP24_YYY_pow(&t1,&t7,x);		// t1=t7^u
 
-	BIG_XXX_fshr(x,1);
-	FP24_YYY_pow(&t2,&t1,x);		// t2=t1^(u/2)
-	BIG_XXX_fshl(x,1);  // x must be even
+    BIG_XXX_fshr(x,1);
+    FP24_YYY_pow(&t2,&t1,x);		// t2=t1^(u/2)
+    BIG_XXX_fshl(x,1);  // x must be even
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP24_YYY_conj(&t1,&t1);
+    FP24_YYY_conj(&t1,&t1);
 #endif
 
-	FP24_YYY_conj(&t3,&t1);		// t3=1/t1
-	FP24_YYY_mul(&t2,&t3);		// t2=t1*t3
-	FP24_YYY_mul(&t2,r);		// t2=t2*f
+    FP24_YYY_conj(&t3,&t1);		// t3=1/t1
+    FP24_YYY_mul(&t2,&t3);		// t2=t1*t3
+    FP24_YYY_mul(&t2,r);		// t2=t2*f
 
 
-	FP24_YYY_pow(&t3,&t2,x);		// t3=t2^u
-	FP24_YYY_pow(&t4,&t3,x);		// t4=t3^u
-	FP24_YYY_pow(&t5,&t4,x);		// t5=t4^u
+    FP24_YYY_pow(&t3,&t2,x);		// t3=t2^u
+    FP24_YYY_pow(&t4,&t3,x);		// t4=t3^u
+    FP24_YYY_pow(&t5,&t4,x);		// t5=t4^u
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP24_YYY_conj(&t3,&t3);
-	FP24_YYY_conj(&t5,&t5);
+    FP24_YYY_conj(&t3,&t3);
+    FP24_YYY_conj(&t5,&t5);
 #endif
 
-	FP24_YYY_frob(&t3,&X,6);
-	FP24_YYY_frob(&t4,&X,5);
+    FP24_YYY_frob(&t3,&X,6);
+    FP24_YYY_frob(&t4,&X,5);
 
-	FP24_YYY_mul(&t3,&t4);		// t3=t3.t4
+    FP24_YYY_mul(&t3,&t4);		// t3=t3.t4
 
 
-	FP24_YYY_pow(&t6,&t5,x);		// t6=t5^u
+    FP24_YYY_pow(&t6,&t5,x);		// t6=t5^u
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP24_YYY_conj(&t6,&t6);
+    FP24_YYY_conj(&t6,&t6);
 #endif
 
 
-	FP24_YYY_frob(&t5,&X,4); 
-	FP24_YYY_mul(&t3,&t5); // ??
+    FP24_YYY_frob(&t5,&X,4);
+    FP24_YYY_mul(&t3,&t5); // ??
 
 
-	FP24_YYY_conj(&t0,&t2);			// t0=1/t2
-	FP24_YYY_mul(&t6,&t0);		// t6=t6*t0
+    FP24_YYY_conj(&t0,&t2);			// t0=1/t2
+    FP24_YYY_mul(&t6,&t0);		// t6=t6*t0
 
-	FP24_YYY_copy(&t5,&t6);
-	FP24_YYY_frob(&t5,&X,3); 
+    FP24_YYY_copy(&t5,&t6);
+    FP24_YYY_frob(&t5,&X,3);
 
-	FP24_YYY_mul(&t3,&t5);		// t3=t3*t5
-	FP24_YYY_pow(&t5,&t6,x);	// t5=t6^x
-	FP24_YYY_pow(&t6,&t5,x);	// t6=t5^x
+    FP24_YYY_mul(&t3,&t5);		// t3=t3*t5
+    FP24_YYY_pow(&t5,&t6,x);	// t5=t6^x
+    FP24_YYY_pow(&t6,&t5,x);	// t6=t5^x
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP24_YYY_conj(&t5,&t5);
+    FP24_YYY_conj(&t5,&t5);
 #endif
 
-	FP24_YYY_copy(&t0,&t5);	
-	FP24_YYY_frob(&t0,&X,2); 
-	FP24_YYY_mul(&t3,&t0);		// t3=t3*t0
-	FP24_YYY_copy(&t0,&t6);     // 
-	FP24_YYY_frob(&t0,&X,1);
+    FP24_YYY_copy(&t0,&t5);
+    FP24_YYY_frob(&t0,&X,2);
+    FP24_YYY_mul(&t3,&t0);		// t3=t3*t0
+    FP24_YYY_copy(&t0,&t6);     //
+    FP24_YYY_frob(&t0,&X,1);
 
-	FP24_YYY_mul(&t3,&t0);		// t3=t3*t0
-	FP24_YYY_pow(&t5,&t6,x);    // t5=t6*x
+    FP24_YYY_mul(&t3,&t0);		// t3=t3*t0
+    FP24_YYY_pow(&t5,&t6,x);    // t5=t6*x
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP24_YYY_conj(&t5,&t5);
+    FP24_YYY_conj(&t5,&t5);
 #endif
 
-	FP24_YYY_frob(&t2,&X,7); 
+    FP24_YYY_frob(&t2,&X,7);
 
-	FP24_YYY_mul(&t5,&t7);		// t5=t5*t7
-	FP24_YYY_mul(&t3,&t2);		// t3=t3*t2
-	FP24_YYY_mul(&t3,&t5);		// t3=t3*t5
+    FP24_YYY_mul(&t5,&t7);		// t5=t5*t7
+    FP24_YYY_mul(&t3,&t2);		// t3=t3*t2
+    FP24_YYY_mul(&t3,&t5);		// t3=t3*t5
 
-	FP24_YYY_mul(r,&t3);
-	FP24_YYY_reduce(r);
+    FP24_YYY_mul(r,&t3);
+    FP24_YYY_reduce(r);
 
 }
 
@@ -473,7 +477,7 @@
     BIG_XXX x,x2,q;
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
     BIG_XXX_smul(x2,x,x);
-	BIG_XXX_smul(x,x2,x2);
+    BIG_XXX_smul(x,x2,x2);
     BIG_XXX_copy(u[0],e);
     BIG_XXX_mod(u[0],x);
     BIG_XXX_copy(u[1],e);
@@ -493,7 +497,7 @@
     int i;
 
     BIG_XXX x,w,q;
-	BIG_XXX_rcopy(q,CURVE_Order_ZZZ);
+    BIG_XXX_rcopy(q,CURVE_Order_ZZZ);
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
     BIG_XXX_copy(w,e);
 
@@ -503,14 +507,14 @@
         BIG_XXX_mod(u[i],x);
         BIG_XXX_sdiv(w,x);
     }
-	BIG_XXX_copy(u[7],w);
+    BIG_XXX_copy(u[7],w);
 
-/*  */
+    /*  */
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	BIG_XXX_modneg(u[1],u[1],q);
-	BIG_XXX_modneg(u[3],u[3],q);
-	BIG_XXX_modneg(u[5],u[5],q);
-	BIG_XXX_modneg(u[7],u[7],q);
+    BIG_XXX_modneg(u[1],u[1],q);
+    BIG_XXX_modneg(u[3],u[3],q);
+    BIG_XXX_modneg(u[5],u[5],q);
+    BIG_XXX_modneg(u[7],u[7],q);
 #endif
 
 
@@ -523,14 +527,15 @@
 #ifdef USE_GLV_ZZZ   /* Note this method is patented */
     int np,nn;
     ECP_ZZZ Q;
-	FP_YYY cru;
+    FP_YYY cru;
     BIG_XXX t,q;
     BIG_XXX u[2];
 
     BIG_XXX_rcopy(q,CURVE_Order_ZZZ);
     glv(u,e);
 
-    ECP_ZZZ_copy(&Q,P); ECP_ZZZ_affine(&Q);
+    ECP_ZZZ_copy(&Q,P);
+    ECP_ZZZ_affine(&Q);
     FP_YYY_rcopy(&cru,CURVE_Cru_ZZZ);
     FP_YYY_mul(&(Q.x),&(Q.x),&cru);
 
@@ -554,7 +559,7 @@
         ECP_ZZZ_neg(&Q);
     }
     BIG_XXX_norm(u[0]);
-    BIG_XXX_norm(u[1]);    
+    BIG_XXX_norm(u[1]);
     ECP_ZZZ_mul2(P,&Q,u[0],u[1]);
 
 #else
@@ -571,7 +576,7 @@
     FP2_YYY X[3];
     BIG_XXX x,y,u[8];
 
-	ECP4_ZZZ_frob_constants(X);
+    ECP4_ZZZ_frob_constants(X);
 
     BIG_XXX_rcopy(y,CURVE_Order_ZZZ);
     gs(u,e);
@@ -593,7 +598,7 @@
             BIG_XXX_copy(u[i],x);
             ECP4_ZZZ_neg(&Q[i]);
         }
-        BIG_XXX_norm(u[i]);   
+        BIG_XXX_norm(u[i]);
     }
 
     ECP4_ZZZ_mul8(P,Q,u);
@@ -611,7 +616,7 @@
     FP24_YYY g[8];
     FP2_YYY X;
     BIG_XXX t,q;
-	FP_YYY fx,fy;
+    FP_YYY fx,fy;
     BIG_XXX u[8];
 
     FP_YYY_rcopy(&fx,Fra_YYY);
@@ -638,7 +643,7 @@
             BIG_XXX_copy(u[i],t);
             FP24_YYY_conj(&g[i],&g[i]);
         }
-        BIG_XXX_norm(u[i]);        
+        BIG_XXX_norm(u[i]);
     }
     FP24_YYY_pow8(f,g,u);
 
@@ -666,16 +671,16 @@
     ECP_ZZZ Q,R;
     FP24 g,gp;
     FP8_YYY t,c,cp,cpm1,cpm2;
-	FP4_YYY X,Y;
+    FP4_YYY X,Y;
     FP2_YYY x,y,f,Aa,Bb;
-	FP_YYY cru;
+    FP_YYY cru;
 
-	for (i=0;i<32;i++)
-		byt[i]=i+9;
-	RAND_seed(&rng,32,byt);
+    for (i=0; i<32; i++)
+        byt[i]=i+9;
+    RAND_seed(&rng,32,byt);
 
-	BIG_XXX_rcopy(r,CURVE_Order);
-	BIG_XXX_rcopy(p,Modulus);
+    BIG_XXX_rcopy(r,CURVE_Order);
+    BIG_XXX_rcopy(p,Modulus);
 
 
     BIG_XXX_rcopy(xa,CURVE_Gx);
@@ -689,7 +694,7 @@
     ECP_output(&Q);
     printf("\n");
 
-	ECP4_ZZZ_generator(&P);
+    ECP4_ZZZ_generator(&P);
 
     if (P.inf) printf("Failed to set - point not on curve\n");
     else printf("G2 set success\n");
@@ -700,7 +705,7 @@
 
     PAIR_ate(&g,&P,&Q);
 
-	printf("gb= ");
+    printf("gb= ");
     FP24_output(&g);
     printf("\n");
     PAIR_fexp(&g);
@@ -709,12 +714,12 @@
     FP24_output(&g);
     printf("\n");
 
-	ECP_copy(&R,&Q);
-	ECP4_ZZZ_copy(&G,&P);
+    ECP_copy(&R,&Q);
+    ECP4_ZZZ_copy(&G,&P);
 
-	ECP4_ZZZ_dbl(&G);
-	ECP_dbl(&R);
-	ECP_affine(&R);
+    ECP4_ZZZ_dbl(&G);
+    ECP_dbl(&R);
+    ECP_affine(&R);
 
     PAIR_ate(&g,&G,&Q);
     PAIR_fexp(&g);
@@ -731,25 +736,33 @@
     printf("\n");
 
 
-	PAIR_G1mul(&Q,r);
-	printf("rQ= ");ECP_output(&Q); printf("\n");
+    PAIR_G1mul(&Q,r);
+    printf("rQ= ");
+    ECP_output(&Q);
+    printf("\n");
 
-	PAIR_G2mul(&P,r);
-	printf("rP= ");ECP4_ZZZ_output(&P); printf("\n");
+    PAIR_G2mul(&P,r);
+    printf("rP= ");
+    ECP4_ZZZ_output(&P);
+    printf("\n");
 
-	BIG_XXX_randomnum(w,r,&rng);
+    BIG_XXX_randomnum(w,r,&rng);
 
-	FP24_copy(&gp,&g);
+    FP24_copy(&gp,&g);
 
-	PAIR_GTpow(&g,w);
+    PAIR_GTpow(&g,w);
 
-	FP24_trace(&t,&g);
+    FP24_trace(&t,&g);
 
-	printf("g^r=  ");FP8_output(&t); printf("\n");
+    printf("g^r=  ");
+    FP8_output(&t);
+    printf("\n");
 
-	FP24_compow(&t,&gp,w,r);
+    FP24_compow(&t,&gp,w,r);
 
-	printf("t(g)= "); FP8_output(&t); printf("\n");
+    printf("t(g)= ");
+    FP8_output(&t);
+    printf("\n");
 
 }
 
diff --git a/version3/c/pair256.c b/version3/c/pair256.c
index 9dab331..2b53ba4 100644
--- a/version3/c/pair256.c
+++ b/version3/c/pair256.c
@@ -26,122 +26,122 @@
 /* Line function */
 static void PAIR_ZZZ_line(FP48_YYY *v,ECP8_ZZZ *A,ECP8_ZZZ *B,FP_YYY *Qx,FP_YYY *Qy)
 {
-	FP8_YYY X1,Y1,T1,T2;
-	FP8_YYY XX,YY,ZZ,YZ;
+    FP8_YYY X1,Y1,T1,T2;
+    FP8_YYY XX,YY,ZZ,YZ;
     FP16_YYY a,b,c;
 
-	if (A==B)
+    if (A==B)
     {
         /* doubling */
- 		FP8_YYY_copy(&XX,&(A->x));	//FP8_YYY XX=new FP8_YYY(A.getx());  //X
-		FP8_YYY_copy(&YY,&(A->y));	//FP8_YYY YY=new FP8_YYY(A.gety());  //Y
-		FP8_YYY_copy(&ZZ,&(A->z));	//FP8_YYY ZZ=new FP8_YYY(A.getz());  //Z
+        FP8_YYY_copy(&XX,&(A->x));	//FP8_YYY XX=new FP8_YYY(A.getx());  //X
+        FP8_YYY_copy(&YY,&(A->y));	//FP8_YYY YY=new FP8_YYY(A.gety());  //Y
+        FP8_YYY_copy(&ZZ,&(A->z));	//FP8_YYY ZZ=new FP8_YYY(A.getz());  //Z
 
 
-		FP8_YYY_copy(&YZ,&YY);		//FP8_YYY YZ=new FP8_YYY(YY);        //Y 
-		FP8_YYY_mul(&YZ,&YZ,&ZZ);		//YZ.mul(ZZ);                //YZ
-		FP8_YYY_sqr(&XX,&XX);		//XX.sqr();	               //X^2
-		FP8_YYY_sqr(&YY,&YY);		//YY.sqr();	               //Y^2
-		FP8_YYY_sqr(&ZZ,&ZZ);		//ZZ.sqr();			       //Z^2
-			
-		FP8_YYY_imul(&YZ,&YZ,4);	//YZ.imul(4);
-		FP8_YYY_neg(&YZ,&YZ);		//YZ.neg(); 
-		FP8_YYY_norm(&YZ);			//YZ.norm();       //-4YZ
+        FP8_YYY_copy(&YZ,&YY);		//FP8_YYY YZ=new FP8_YYY(YY);        //Y
+        FP8_YYY_mul(&YZ,&YZ,&ZZ);		//YZ.mul(ZZ);                //YZ
+        FP8_YYY_sqr(&XX,&XX);		//XX.sqr();	               //X^2
+        FP8_YYY_sqr(&YY,&YY);		//YY.sqr();	               //Y^2
+        FP8_YYY_sqr(&ZZ,&ZZ);		//ZZ.sqr();			       //Z^2
 
-		FP8_YYY_imul(&XX,&XX,6);					//6X^2
-		FP8_YYY_tmul(&XX,&XX,Qx);	               //6X^2.Xs
+        FP8_YYY_imul(&YZ,&YZ,4);	//YZ.imul(4);
+        FP8_YYY_neg(&YZ,&YZ);		//YZ.neg();
+        FP8_YYY_norm(&YZ);			//YZ.norm();       //-4YZ
 
-		FP8_YYY_imul(&ZZ,&ZZ,3*CURVE_B_I_ZZZ);	//3Bz^2 
-		FP8_YYY_tmul(&YZ,&YZ,Qy);	//-4YZ.Ys
+        FP8_YYY_imul(&XX,&XX,6);					//6X^2
+        FP8_YYY_tmul(&XX,&XX,Qx);	               //6X^2.Xs
+
+        FP8_YYY_imul(&ZZ,&ZZ,3*CURVE_B_I_ZZZ);	//3Bz^2
+        FP8_YYY_tmul(&YZ,&YZ,Qy);	//-4YZ.Ys
 
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-		FP8_YYY_div_2i(&ZZ);		//6(b/i)z^2
+        FP8_YYY_div_2i(&ZZ);		//6(b/i)z^2
 #endif
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-		FP8_YYY_times_i(&ZZ);
-		FP8_YYY_add(&ZZ,&ZZ,&ZZ);  // 6biz^2
-		FP8_YYY_times_i(&YZ);
-		FP8_YYY_norm(&YZ);	
+        FP8_YYY_times_i(&ZZ);
+        FP8_YYY_add(&ZZ,&ZZ,&ZZ);  // 6biz^2
+        FP8_YYY_times_i(&YZ);
+        FP8_YYY_norm(&YZ);
 #endif
-		FP8_YYY_norm(&ZZ);			// 6bi.Z^2 
+        FP8_YYY_norm(&ZZ);			// 6bi.Z^2
 
-		FP8_YYY_add(&YY,&YY,&YY);	// 2y^2
-		FP8_YYY_sub(&ZZ,&ZZ,&YY);	// 
-		FP8_YYY_norm(&ZZ);			// 6b.Z^2-2Y^2
+        FP8_YYY_add(&YY,&YY,&YY);	// 2y^2
+        FP8_YYY_sub(&ZZ,&ZZ,&YY);	//
+        FP8_YYY_norm(&ZZ);			// 6b.Z^2-2Y^2
 
-		FP16_YYY_from_FP8s(&a,&YZ,&ZZ); // -4YZ.Ys | 6b.Z^2-2Y^2 | 6X^2.Xs 
+        FP16_YYY_from_FP8s(&a,&YZ,&ZZ); // -4YZ.Ys | 6b.Z^2-2Y^2 | 6X^2.Xs
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-		FP16_YYY_from_FP8(&b,&XX);	
-		FP16_YYY_zero(&c);
+        FP16_YYY_from_FP8(&b,&XX);
+        FP16_YYY_zero(&c);
 #endif
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-		FP16_YYY_zero(&b);
-		FP16_YYY_from_FP8H(&c,&XX);
+        FP16_YYY_zero(&b);
+        FP16_YYY_from_FP8H(&c,&XX);
 #endif
 
-		ECP8_ZZZ_dbl(A);				//A.dbl();
+        ECP8_ZZZ_dbl(A);				//A.dbl();
     }
     else
     {
         /* addition */
 
-		FP8_YYY_copy(&X1,&(A->x));		//FP8_YYY X1=new FP8_YYY(A.getx());    // X1
-		FP8_YYY_copy(&Y1,&(A->y));		//FP8_YYY Y1=new FP8_YYY(A.gety());    // Y1
-		FP8_YYY_copy(&T1,&(A->z));		//FP8_YYY T1=new FP8_YYY(A.getz());    // Z1
-			
-		FP8_YYY_copy(&T2,&T1);		//FP8_YYY T2=new FP8_YYY(A.getz());    // Z1
+        FP8_YYY_copy(&X1,&(A->x));		//FP8_YYY X1=new FP8_YYY(A.getx());    // X1
+        FP8_YYY_copy(&Y1,&(A->y));		//FP8_YYY Y1=new FP8_YYY(A.gety());    // Y1
+        FP8_YYY_copy(&T1,&(A->z));		//FP8_YYY T1=new FP8_YYY(A.getz());    // Z1
 
-		FP8_YYY_mul(&T1,&T1,&(B->y));	//T1.mul(B.gety());    // T1=Z1.Y2 
-		FP8_YYY_mul(&T2,&T2,&(B->x));	//T2.mul(B.getx());    // T2=Z1.X2
+        FP8_YYY_copy(&T2,&T1);		//FP8_YYY T2=new FP8_YYY(A.getz());    // Z1
 
-		FP8_YYY_sub(&X1,&X1,&T2);		//X1.sub(T2); 
-		FP8_YYY_norm(&X1);				//X1.norm();  // X1=X1-Z1.X2
-		FP8_YYY_sub(&Y1,&Y1,&T1);		//Y1.sub(T1); 
-		FP8_YYY_norm(&Y1);				//Y1.norm();  // Y1=Y1-Z1.Y2
+        FP8_YYY_mul(&T1,&T1,&(B->y));	//T1.mul(B.gety());    // T1=Z1.Y2
+        FP8_YYY_mul(&T2,&T2,&(B->x));	//T2.mul(B.getx());    // T2=Z1.X2
 
-		FP8_YYY_copy(&T1,&X1);			//T1.copy(X1);            // T1=X1-Z1.X2
-		FP8_YYY_tmul(&X1,&X1,Qy);		//X1.pmul(Qy);            // X1=(X1-Z1.X2).Ys
+        FP8_YYY_sub(&X1,&X1,&T2);		//X1.sub(T2);
+        FP8_YYY_norm(&X1);				//X1.norm();  // X1=X1-Z1.X2
+        FP8_YYY_sub(&Y1,&Y1,&T1);		//Y1.sub(T1);
+        FP8_YYY_norm(&Y1);				//Y1.norm();  // Y1=Y1-Z1.Y2
+
+        FP8_YYY_copy(&T1,&X1);			//T1.copy(X1);            // T1=X1-Z1.X2
+        FP8_YYY_tmul(&X1,&X1,Qy);		//X1.pmul(Qy);            // X1=(X1-Z1.X2).Ys
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-		FP8_YYY_times_i(&X1);
-		FP8_YYY_norm(&X1);
+        FP8_YYY_times_i(&X1);
+        FP8_YYY_norm(&X1);
 #endif
 
-		FP8_YYY_mul(&T1,&T1,&(B->y));	//T1.mul(B.gety());       // T1=(X1-Z1.X2).Y2
+        FP8_YYY_mul(&T1,&T1,&(B->y));	//T1.mul(B.gety());       // T1=(X1-Z1.X2).Y2
 
-		FP8_YYY_copy(&T2,&Y1);			//T2.copy(Y1);            // T2=Y1-Z1.Y2
-		FP8_YYY_mul(&T2,&T2,&(B->x));	//T2.mul(B.getx());       // T2=(Y1-Z1.Y2).X2
-		FP8_YYY_sub(&T2,&T2,&T1);		//T2.sub(T1); 
-		FP8_YYY_norm(&T2);				//T2.norm();          // T2=(Y1-Z1.Y2).X2 - (X1-Z1.X2).Y2
-		FP8_YYY_tmul(&Y1,&Y1,Qx);		//Y1.pmul(Qx);  
-		FP8_YYY_neg(&Y1,&Y1);			//Y1.neg(); 
-		FP8_YYY_norm(&Y1);				//Y1.norm(); // Y1=-(Y1-Z1.Y2).Xs
+        FP8_YYY_copy(&T2,&Y1);			//T2.copy(Y1);            // T2=Y1-Z1.Y2
+        FP8_YYY_mul(&T2,&T2,&(B->x));	//T2.mul(B.getx());       // T2=(Y1-Z1.Y2).X2
+        FP8_YYY_sub(&T2,&T2,&T1);		//T2.sub(T1);
+        FP8_YYY_norm(&T2);				//T2.norm();          // T2=(Y1-Z1.Y2).X2 - (X1-Z1.X2).Y2
+        FP8_YYY_tmul(&Y1,&Y1,Qx);		//Y1.pmul(Qx);
+        FP8_YYY_neg(&Y1,&Y1);			//Y1.neg();
+        FP8_YYY_norm(&Y1);				//Y1.norm(); // Y1=-(Y1-Z1.Y2).Xs
 
-		FP16_YYY_from_FP8s(&a,&X1,&T2);	// (X1-Z1.X2).Ys  |  (Y1-Z1.Y2).X2 - (X1-Z1.X2).Y2  | - (Y1-Z1.Y2).Xs
+        FP16_YYY_from_FP8s(&a,&X1,&T2);	// (X1-Z1.X2).Ys  |  (Y1-Z1.Y2).X2 - (X1-Z1.X2).Y2  | - (Y1-Z1.Y2).Xs
 #if SEXTIC_TWIST_ZZZ==D_TYPE
-		FP16_YYY_from_FP8(&b,&Y1);		//b=new FP4(Y1);
-		FP16_YYY_zero(&c);
+        FP16_YYY_from_FP8(&b,&Y1);		//b=new FP4(Y1);
+        FP16_YYY_zero(&c);
 #endif
 #if SEXTIC_TWIST_ZZZ==M_TYPE
-		FP16_YYY_zero(&b);
-		FP16_YYY_from_FP8H(&c,&Y1);		//b=new FP4(Y1);
+        FP16_YYY_zero(&b);
+        FP16_YYY_from_FP8H(&c,&Y1);		//b=new FP4(Y1);
 #endif
-		ECP8_ZZZ_add(A,B);			// A.add(B);
+        ECP8_ZZZ_add(A,B);			// A.add(B);
     }
 
     FP48_YYY_from_FP16s(v,&a,&b,&c);
-	v->type=FP_SPARSER;
+    v->type=AMCL_AMCL_FP_SPARSER;
 }
 
 /* prepare ate parameter, n=6u+2 (BN) or n=u (BLS), n3=3*n */
 int PAIR_ZZZ_nbits(BIG_XXX n3,BIG_XXX n)
 {
-	BIG_XXX x;
+    BIG_XXX x;
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
 
     BIG_XXX_copy(n,x);
     BIG_XXX_norm(n);
-	BIG_XXX_pmul(n3,n,3);
-	BIG_XXX_norm(n3);
+    BIG_XXX_pmul(n3,n,3);
+    BIG_XXX_norm(n3);
 
     return BIG_XXX_nbits(n3);
 }
@@ -158,117 +158,119 @@
 /* prepare for multi-pairing */
 void PAIR_ZZZ_initmp(FP48_YYY r[])
 {
-	int i;
-	for (i=ATE_BITS_ZZZ-1; i>=0; i--)
-		FP48_YYY_one(&r[i]);
-	return;
+    int i;
+    for (i=ATE_BITS_ZZZ-1; i>=0; i--)
+        FP48_YYY_one(&r[i]);
+    return;
 }
 
 /* basic Miller loop */
 void PAIR_ZZZ_miller(FP48_YYY *res,FP48_YYY r[])
 {
-	int i;
+    int i;
     FP48_YYY_one(res);
-	for (i=ATE_BITS_ZZZ-1; i>=1; i--)
-	{
-		FP48_YYY_sqr(res,res);
-		FP48_YYY_ssmul(res,&r[i]);
-	}
+    for (i=ATE_BITS_ZZZ-1; i>=1; i--)
+    {
+        FP48_YYY_sqr(res,res);
+        FP48_YYY_ssmul(res,&r[i]);
+    }
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
     FP48_YYY_conj(res,res);
 #endif
-	FP48_YYY_ssmul(res,&r[0]);
-	return;
+    FP48_YYY_ssmul(res,&r[0]);
+    return;
 }
 
 /* Accumulate another set of line functions for n-pairing */
 void PAIR_ZZZ_another(FP48_YYY r[],ECP8_ZZZ* PV,ECP_ZZZ* QV)
 {
-    int i,j,nb,bt;
-	BIG_XXX x,n,n3;
+    int i,nb,bt;
+    BIG_XXX n,n3;
     FP48_YYY lv,lv2;
     ECP8_ZZZ A,NP,P;
-	ECP_ZZZ Q;
-	FP_YYY Qx,Qy;
+    ECP_ZZZ Q;
+    FP_YYY Qx,Qy;
 
-	nb=PAIR_ZZZ_nbits(n3,n);
+    nb=PAIR_ZZZ_nbits(n3,n);
 
-	ECP8_ZZZ_copy(&P,PV);
-	ECP_ZZZ_copy(&Q,QV);
+    ECP8_ZZZ_copy(&P,PV);
+    ECP_ZZZ_copy(&Q,QV);
 
-	ECP8_ZZZ_affine(&P);
-	ECP_ZZZ_affine(&Q);
+    ECP8_ZZZ_affine(&P);
+    ECP_ZZZ_affine(&Q);
 
-	FP_YYY_copy(&Qx,&(Q.x));
-	FP_YYY_copy(&Qy,&(Q.y));
+    FP_YYY_copy(&Qx,&(Q.x));
+    FP_YYY_copy(&Qy,&(Q.y));
 
-	ECP8_ZZZ_copy(&A,&P);
-	ECP8_ZZZ_copy(&NP,&P); ECP8_ZZZ_neg(&NP);
+    ECP8_ZZZ_copy(&A,&P);
+    ECP8_ZZZ_copy(&NP,&P);
+    ECP8_ZZZ_neg(&NP);
 
-	for (i=nb-2; i>=1; i--)
-	{
-		PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
+    for (i=nb-2; i>=1; i--)
+    {
+        PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
 
-		bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
-		if (bt==1)
-		{
-			PAIR_ZZZ_line(&lv2,&A,&P,&Qx,&Qy);
-			FP48_YYY_smul(&lv,&lv2);
-		}
-		if (bt==-1)
-		{
-			PAIR_ZZZ_line(&lv2,&A,&NP,&Qx,&Qy);
-			FP48_YYY_smul(&lv,&lv2);
-		}
-		FP48_YYY_ssmul(&r[i],&lv);
-	}
+        bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
+        if (bt==1)
+        {
+            PAIR_ZZZ_line(&lv2,&A,&P,&Qx,&Qy);
+            FP48_YYY_smul(&lv,&lv2);
+        }
+        if (bt==-1)
+        {
+            PAIR_ZZZ_line(&lv2,&A,&NP,&Qx,&Qy);
+            FP48_YYY_smul(&lv,&lv2);
+        }
+        FP48_YYY_ssmul(&r[i],&lv);
+    }
 }
 
 /* Optimal R-ate pairing r=e(P,Q) */
 void PAIR_ZZZ_ate(FP48_YYY *r,ECP8_ZZZ *P1,ECP_ZZZ *Q1)
 {
-    BIG_XXX x,n,n3;
-	FP_YYY Qx,Qy;
+    BIG_XXX n,n3;
+    FP_YYY Qx,Qy;
     int i,nb,bt;
     ECP8_ZZZ A,NP,P;
-	ECP_ZZZ Q;
+    ECP_ZZZ Q;
     FP48_YYY lv,lv2;
 
-	nb=PAIR_ZZZ_nbits(n3,n);
+    nb=PAIR_ZZZ_nbits(n3,n);
 
-	ECP8_ZZZ_copy(&P,P1);
-	ECP_ZZZ_copy(&Q,Q1);
+    ECP8_ZZZ_copy(&P,P1);
+    ECP_ZZZ_copy(&Q,Q1);
 
-	ECP8_ZZZ_affine(&P);
-	ECP_ZZZ_affine(&Q);
+    ECP8_ZZZ_affine(&P);
+    ECP_ZZZ_affine(&Q);
 
 
     FP_YYY_copy(&Qx,&(Q.x));
     FP_YYY_copy(&Qy,&(Q.y));
 
     ECP8_ZZZ_copy(&A,&P);
-	ECP8_ZZZ_copy(&NP,&P); ECP8_ZZZ_neg(&NP);
+    ECP8_ZZZ_copy(&NP,&P);
+    ECP8_ZZZ_neg(&NP);
 
     FP48_YYY_one(r);
 
     /* Main Miller Loop */
     for (i=nb-2; i>=1; i--)
     {
-		FP48_YYY_sqr(r,r);
+        FP48_YYY_sqr(r,r);
         PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
 
-		bt= BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i);  // BIG_bit(n,i); 
+        bt= BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i);  // BIG_bit(n,i);
         if (bt==1)
         {
             PAIR_ZZZ_line(&lv2,&A,&P,&Qx,&Qy);
             FP48_YYY_smul(&lv,&lv2);
         }
-		if (bt==-1)
-		{
+        if (bt==-1)
+        {
             PAIR_ZZZ_line(&lv2,&A,&NP,&Qx,&Qy);
             FP48_YYY_smul(&lv,&lv2);
-		}
+        }
         FP48_YYY_ssmul(r,&lv);
     }
 
@@ -281,26 +283,26 @@
 /* Optimal R-ate double pairing e(P,Q).e(R,S) */
 void PAIR_ZZZ_double_ate(FP48_YYY *r,ECP8_ZZZ *P1,ECP_ZZZ *Q1,ECP8_ZZZ *R1,ECP_ZZZ *S1)
 {
-    BIG_XXX x,n,n3;
-	FP_YYY Qx,Qy,Sx,Sy;
+    BIG_XXX n,n3;
+    FP_YYY Qx,Qy,Sx,Sy;
     int i,nb,bt;
     ECP8_ZZZ A,B,NP,NR,P,R;
-	ECP_ZZZ Q,S;
+    ECP_ZZZ Q,S;
     FP48_YYY lv,lv2;
 
-	nb=PAIR_ZZZ_nbits(n3,n);
+    nb=PAIR_ZZZ_nbits(n3,n);
 
-	ECP8_ZZZ_copy(&P,P1);
-	ECP_ZZZ_copy(&Q,Q1);
+    ECP8_ZZZ_copy(&P,P1);
+    ECP_ZZZ_copy(&Q,Q1);
 
-	ECP8_ZZZ_affine(&P);
-	ECP_ZZZ_affine(&Q);
+    ECP8_ZZZ_affine(&P);
+    ECP_ZZZ_affine(&Q);
 
-	ECP8_ZZZ_copy(&R,R1);
-	ECP_ZZZ_copy(&S,S1);
+    ECP8_ZZZ_copy(&R,R1);
+    ECP_ZZZ_copy(&S,S1);
 
-	ECP8_ZZZ_affine(&R);
-	ECP_ZZZ_affine(&S);
+    ECP8_ZZZ_affine(&R);
+    ECP_ZZZ_affine(&S);
 
     FP_YYY_copy(&Qx,&(Q.x));
     FP_YYY_copy(&Qy,&(Q.y));
@@ -310,8 +312,10 @@
 
     ECP8_ZZZ_copy(&A,&P);
     ECP8_ZZZ_copy(&B,&R);
-	ECP8_ZZZ_copy(&NP,&P); ECP8_ZZZ_neg(&NP);
-	ECP8_ZZZ_copy(&NR,&R); ECP8_ZZZ_neg(&NR);
+    ECP8_ZZZ_copy(&NP,&P);
+    ECP8_ZZZ_neg(&NP);
+    ECP8_ZZZ_copy(&NR,&R);
+    ECP8_ZZZ_neg(&NR);
 
     FP48_YYY_one(r);
 
@@ -320,26 +324,26 @@
     {
         FP48_YYY_sqr(r,r);
         PAIR_ZZZ_line(&lv,&A,&A,&Qx,&Qy);
-		PAIR_ZZZ_line(&lv2,&B,&B,&Sx,&Sy);
+        PAIR_ZZZ_line(&lv2,&B,&B,&Sx,&Sy);
         FP48_YYY_smul(&lv,&lv2);
         FP48_YYY_ssmul(r,&lv);
 
-		bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
+        bt=BIG_XXX_bit(n3,i)-BIG_XXX_bit(n,i); // bt=BIG_bit(n,i);
         if (bt==1)
         {
             PAIR_ZZZ_line(&lv,&A,&P,&Qx,&Qy);
             PAIR_ZZZ_line(&lv2,&B,&R,&Sx,&Sy);
-			FP48_YYY_smul(&lv,&lv2);
+            FP48_YYY_smul(&lv,&lv2);
             FP48_YYY_ssmul(r,&lv);
         }
-		if (bt==-1)
-		{
+        if (bt==-1)
+        {
             PAIR_ZZZ_line(&lv,&A,&NP,&Qx,&Qy);
             PAIR_ZZZ_line(&lv2,&B,&NR,&Sx,&Sy);
             FP48_YYY_smul(&lv,&lv2);
             FP48_YYY_ssmul(r,&lv);
-		}
-	}
+        }
+    }
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
     FP48_YYY_conj(r,r);
@@ -353,8 +357,8 @@
 {
     FP2_YYY X;
     BIG_XXX x;
-	FP_YYY a,b;
-    FP48_YYY t1,t2,t3,t7;  
+    FP_YYY a,b;
+    FP48_YYY t1,t2,t3,t7;
 
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
     FP_YYY_rcopy(&a,Fra_YYY);
@@ -373,156 +377,156 @@
 
     FP48_YYY_mul(r,&t7);
 
-	if (FP48_YYY_isunity(r))
-	{
-		FP48_YYY_zero(r);
-		return;
-	}
+    if (FP48_YYY_isunity(r))
+    {
+        FP48_YYY_zero(r);
+        return;
+    }
 
 // f^e0.f^e1^p.f^e2^p^2.. .. f^e14^p^14.f^e15^p^15
 
-	FP48_YYY_usqr(&t7,r);			// t7=f^2
-	FP48_YYY_pow(&t1,&t7,x);		// t1=f^2u
+    FP48_YYY_usqr(&t7,r);			// t7=f^2
+    FP48_YYY_pow(&t1,&t7,x);		// t1=f^2u
 
-	BIG_XXX_fshr(x,1);
-	FP48_YYY_pow(&t2,&t1,x);		// t2=f^2u^(u/2) =  f^u^2
-	BIG_XXX_fshl(x,1);				// x must be even
+    BIG_XXX_fshr(x,1);
+    FP48_YYY_pow(&t2,&t1,x);		// t2=f^2u^(u/2) =  f^u^2
+    BIG_XXX_fshl(x,1);				// x must be even
 
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
 
-	FP48_YYY_conj(&t3,&t1);		// t3=f^-2u
-	FP48_YYY_mul(&t2,&t3);		// t2=f^u^2.f^-2u
-	FP48_YYY_mul(&t2,r);		// t2=f^u^2.f^-2u.f = f^(u^2-2u+1) = f^e15
+    FP48_YYY_conj(&t3,&t1);		// t3=f^-2u
+    FP48_YYY_mul(&t2,&t3);		// t2=f^u^2.f^-2u
+    FP48_YYY_mul(&t2,r);		// t2=f^u^2.f^-2u.f = f^(u^2-2u+1) = f^e15
 
-	FP48_YYY_mul(r,&t7);		// f^3
+    FP48_YYY_mul(r,&t7);		// f^3
 
-	FP48_YYY_pow(&t1,&t2,x);	// f^e15^u = f^(u.e15) = f^(u^3-2u^2+u) = f^(e14)
+    FP48_YYY_pow(&t1,&t2,x);	// f^e15^u = f^(u.e15) = f^(u^3-2u^2+u) = f^(e14)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,14);	// f^(u^3-2u^2+u)^p^14
-	FP48_YYY_mul(r,&t3);		// f^3.f^(u^3-2u^2+u)^p^14
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,14);	// f^(u^3-2u^2+u)^p^14
+    FP48_YYY_mul(r,&t3);		// f^3.f^(u^3-2u^2+u)^p^14
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e14) = f^(u^4-2u^3+u^2) =  f^(e13)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e14) = f^(u^4-2u^3+u^2) =  f^(e13)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,13);	// f^(e13)^p^13
-	FP48_YYY_mul(r,&t3);		// f^3.f^(u^3-2u^2+u)^p^14.f^(u^4-2u^3+u^2)^p^13
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,13);	// f^(e13)^p^13
+    FP48_YYY_mul(r,&t3);		// f^3.f^(u^3-2u^2+u)^p^14.f^(u^4-2u^3+u^2)^p^13
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e13)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e13)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,12);	// f^(e12)^p^12
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,12);	// f^(e12)^p^12
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e12)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e12)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,11);	// f^(e11)^p^11
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,11);	// f^(e11)^p^11
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e11)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e11)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,10);	// f^(e10)^p^10
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,10);	// f^(e10)^p^10
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e10)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e10)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,9);	// f^(e9)^p^9
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,9);	// f^(e9)^p^9
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e9)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e9)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,8);	// f^(e8)^p^8
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,8);	// f^(e8)^p^8
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e8)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e8)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_conj(&t3,&t2);
-	FP48_YYY_mul(&t1,&t3);  // f^(u.e8).f^-e15
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,7);	// f^(e7)^p^7
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_conj(&t3,&t2);
+    FP48_YYY_mul(&t1,&t3);  // f^(u.e8).f^-e15
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,7);	// f^(e7)^p^7
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e7)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e7)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,6);	// f^(e6)^p^6
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,6);	// f^(e6)^p^6
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e6)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e6)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,5);	// f^(e5)^p^5
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,5);	// f^(e5)^p^5
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e5)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e5)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,4);	// f^(e4)^p^4
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,4);	// f^(e4)^p^4
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e4)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e4)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,3);	// f^(e3)^p^3
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,3);	// f^(e3)^p^3
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e3)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e3)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,2);	// f^(e2)^p^2
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,2);	// f^(e2)^p^2
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e2)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e2)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_copy(&t3,&t1);
-	FP48_YYY_frob(&t3,&X,1);	// f^(e1)^p^1
-	FP48_YYY_mul(r,&t3);		
+    FP48_YYY_copy(&t3,&t1);
+    FP48_YYY_frob(&t3,&X,1);	// f^(e1)^p^1
+    FP48_YYY_mul(r,&t3);
 
-	FP48_YYY_pow(&t1,&t1,x);	// f^(u.e1)
+    FP48_YYY_pow(&t1,&t1,x);	// f^(u.e1)
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	FP48_YYY_conj(&t1,&t1);
+    FP48_YYY_conj(&t1,&t1);
 #endif
-	FP48_YYY_mul(r,&t1);		// r.f^e0		
+    FP48_YYY_mul(r,&t1);		// r.f^e0
 
-	FP48_YYY_frob(&t2,&X,15);	// f^(e15.p^15)
-	FP48_YYY_mul(r,&t2);
+    FP48_YYY_frob(&t2,&X,15);	// f^(e15.p^15)
+    FP48_YYY_mul(r,&t2);
 
 
-	FP48_YYY_reduce(r);
+    FP48_YYY_reduce(r);
 
 }
 
@@ -535,10 +539,10 @@
 
     BIG_XXX x,x2,q;
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
-    
-	BIG_XXX_smul(x2,x,x);
-	BIG_XXX_smul(x,x2,x2);
-	BIG_XXX_smul(x2,x,x);
+
+    BIG_XXX_smul(x2,x,x);
+    BIG_XXX_smul(x,x2,x2);
+    BIG_XXX_smul(x2,x,x);
 
     BIG_XXX_copy(u[0],e);
     BIG_XXX_mod(u[0],x2);
@@ -559,7 +563,7 @@
     int i;
 
     BIG_XXX x,w,q;
-	BIG_XXX_rcopy(q,CURVE_Order_ZZZ);
+    BIG_XXX_rcopy(q,CURVE_Order_ZZZ);
     BIG_XXX_rcopy(x,CURVE_Bnx_ZZZ);
     BIG_XXX_copy(w,e);
 
@@ -569,18 +573,18 @@
         BIG_XXX_mod(u[i],x);
         BIG_XXX_sdiv(w,x);
     }
-	BIG_XXX_copy(u[15],w);
+    BIG_XXX_copy(u[15],w);
 
-/*  */
+    /*  */
 #if SIGN_OF_X_ZZZ==NEGATIVEX
-	BIG_XXX_modneg(u[1],u[1],q);
-	BIG_XXX_modneg(u[3],u[3],q);
-	BIG_XXX_modneg(u[5],u[5],q);
-	BIG_XXX_modneg(u[7],u[7],q);
-	BIG_XXX_modneg(u[9],u[9],q);
-	BIG_XXX_modneg(u[11],u[11],q);
-	BIG_XXX_modneg(u[13],u[13],q);
-	BIG_XXX_modneg(u[15],u[15],q);
+    BIG_XXX_modneg(u[1],u[1],q);
+    BIG_XXX_modneg(u[3],u[3],q);
+    BIG_XXX_modneg(u[5],u[5],q);
+    BIG_XXX_modneg(u[7],u[7],q);
+    BIG_XXX_modneg(u[9],u[9],q);
+    BIG_XXX_modneg(u[11],u[11],q);
+    BIG_XXX_modneg(u[13],u[13],q);
+    BIG_XXX_modneg(u[15],u[15],q);
 #endif
 
 
@@ -593,14 +597,15 @@
 #ifdef USE_GLV_ZZZ   /* Note this method is patented */
     int np,nn;
     ECP_ZZZ Q;
-	FP_YYY cru;
+    FP_YYY cru;
     BIG_XXX t,q;
     BIG_XXX u[2];
 
     BIG_XXX_rcopy(q,CURVE_Order_ZZZ);
     glv(u,e);
 
-    ECP_ZZZ_copy(&Q,P); ECP_ZZZ_affine(&Q);
+    ECP_ZZZ_copy(&Q,P);
+    ECP_ZZZ_affine(&Q);
     FP_YYY_rcopy(&cru,CURVE_Cru_ZZZ);
     FP_YYY_mul(&(Q.x),&(Q.x),&cru);
 
@@ -624,7 +629,7 @@
         ECP_ZZZ_neg(&Q);
     }
     BIG_XXX_norm(u[0]);
-    BIG_XXX_norm(u[1]);    
+    BIG_XXX_norm(u[1]);
     ECP_ZZZ_mul2(P,&Q,u[0],u[1]);
 
 #else
@@ -641,7 +646,7 @@
     FP2_YYY X[3];
     BIG_XXX x,y,u[16];
 
-	ECP8_ZZZ_frob_constants(X);
+    ECP8_ZZZ_frob_constants(X);
 
     BIG_XXX_rcopy(y,CURVE_Order_ZZZ);
     gs(u,e);
@@ -663,7 +668,7 @@
             BIG_XXX_copy(u[i],x);
             ECP8_ZZZ_neg(&Q[i]);
         }
-        BIG_XXX_norm(u[i]);  
+        BIG_XXX_norm(u[i]);
     }
 
     ECP8_ZZZ_mul16(P,Q,u);
@@ -681,7 +686,7 @@
     FP48_YYY g[16];
     FP2_YYY X;
     BIG_XXX t,q;
-	FP_YYY fx,fy;
+    FP_YYY fx,fy;
     BIG_XXX u[16];
 
     FP_YYY_rcopy(&fx,Fra_YYY);
@@ -735,16 +740,16 @@
     ECP Q,R;
     FP48 g,gp;
     FP16 t,c,cp,cpm1,cpm2;
-	FP8 X,Y;
+    FP8 X,Y;
     FP2 x,y,f,Aa,Bb;
-	FP cru;
+    FP cru;
 
-	for (i=0;i<32;i++)
-		byt[i]=i+9;
-	RAND_seed(&rng,32,byt);
+    for (i=0; i<32; i++)
+        byt[i]=i+9;
+    RAND_seed(&rng,32,byt);
 
-	BIG_rcopy(r,CURVE_Order);
-	BIG_rcopy(p,Modulus);
+    BIG_rcopy(r,CURVE_Order);
+    BIG_rcopy(p,Modulus);
 
 
     BIG_rcopy(xa,CURVE_Gx_ZZZ);
@@ -758,7 +763,7 @@
     ECP_ZZZ_output(&Q);
     printf("\n");
 
-	ECP8_generator(&P);
+    ECP8_generator(&P);
 
     if (P.inf) printf("Failed to set - point not on curve\n");
     else printf("G2 set success\n");
@@ -769,7 +774,7 @@
 
     PAIR_ZZZ_ate(&g,&P,&Q);
 
-	printf("gb= ");
+    printf("gb= ");
     FP48_output(&g);
     printf("\n");
     PAIR_ZZZ_fexp(&g);
@@ -778,12 +783,12 @@
     FP48_output(&g);
     printf("\n");
 
-	ECP_ZZZ_copy(&R,&Q);
-	ECP8_copy(&G,&P);
+    ECP_ZZZ_copy(&R,&Q);
+    ECP8_copy(&G,&P);
 
-	ECP8_dbl(&G);
-	ECP_dbl(&R);
-	ECP_affine(&R);
+    ECP8_dbl(&G);
+    ECP_dbl(&R);
+    ECP_affine(&R);
 
     PAIR_ZZZ_ate(&g,&G,&Q);
     PAIR_ZZZ_fexp(&g);
@@ -800,29 +805,39 @@
     printf("\n");
 
 
-	PAIR_ZZZ_G1mul(&Q,r);
-	printf("rQ= ");ECP_output(&Q); printf("\n");
+    PAIR_ZZZ_G1mul(&Q,r);
+    printf("rQ= ");
+    ECP_output(&Q);
+    printf("\n");
 
-	PAIR_ZZZ_G2mul(&P,r);
-	printf("rP= ");ECP8_output(&P); printf("\n");
+    PAIR_ZZZ_G2mul(&P,r);
+    printf("rP= ");
+    ECP8_output(&P);
+    printf("\n");
 
-	PAIR_ZZZ_GTpow(&g,r);
-	printf("g^r= ");FP48_output(&g); printf("\n");
+    PAIR_ZZZ_GTpow(&g,r);
+    printf("g^r= ");
+    FP48_output(&g);
+    printf("\n");
 
 
-	BIG_randomnum(w,r,&rng);
+    BIG_randomnum(w,r,&rng);
 
-	FP48_copy(&gp,&g);
+    FP48_copy(&gp,&g);
 
-	PAIR_ZZZ_GTpow(&g,w);
+    PAIR_ZZZ_GTpow(&g,w);
 
-	FP48_trace(&t,&g);
+    FP48_trace(&t,&g);
 
-	printf("g^r=  ");FP16_output(&t); printf("\n");
+    printf("g^r=  ");
+    FP16_output(&t);
+    printf("\n");
 
-	FP48_compow(&t,&gp,w,r);
+    FP48_compow(&t,&gp,w,r);
 
-	printf("t(g)= "); FP16_output(&t); printf("\n");
+    printf("t(g)= ");
+    FP16_output(&t);
+    printf("\n");
 
 }
 
diff --git a/version3/c/rom_curve_ANSSI.c b/version3/c/rom_curve_ANSSI.c
index 535a697..075b733 100644
--- a/version3/c/rom_curve_ANSSI.c
+++ b/version3/c/rom_curve_ANSSI.c
@@ -10,7 +10,7 @@
 #endif
 
 #if CHUNK==32
-const int CURVE_Cof_I_ANNSI= 1;
+const int CURVE_Cof_I_ANSSI= 1;
 const BIG_256_28 CURVE_Cof_ANSSI= {0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
 const int CURVE_A_ANSSI= -3;
 const int CURVE_B_I_ANSSI= 0;
@@ -21,7 +21,7 @@
 #endif
 
 #if CHUNK==64
-const int CURVE_Cof_I_ANNSI= 1;
+const int CURVE_Cof_I_ANSSI= 1;
 const BIG_256_56 CURVE_Cof_ANSSI= {0x1L,0x0L,0x0L,0x0L,0x0L};
 const int CURVE_A_ANSSI= -3;
 const int CURVE_B_I_ANSSI= 0;
diff --git a/version3/c/rsa.h b/version3/c/rsa.h
index 4d4c3c1..08a744f 100644
--- a/version3/c/rsa.h
+++ b/version3/c/rsa.h
@@ -18,7 +18,7 @@
 */
 
 /**
- * @file rsa.h
+ * @file rsa_WWW.h
  * @author Mike Scott
  * @brief RSA Header file for implementation of RSA protocol
  *
diff --git a/version3/c/rsa_support.h b/version3/c/rsa_support.h
index 3bd495f..519d012 100644
--- a/version3/c/rsa_support.h
+++ b/version3/c/rsa_support.h
@@ -46,7 +46,7 @@
 	@param R is a pointer to a cryptographically secure random number generator
 	@param P are input encoding parameter string (could be NULL)
 	@param F is the output encoding, ready for RSA encryption
-	@return 1 if OK, else 0
+	@return 0 if OK, else 1
  */
 extern int	OAEP_ENCODE(int h,octet *M,csprng *R,octet *P,octet *F);
 /**	@brief OAEP unpadding of a message after RSA decryption
@@ -55,7 +55,7 @@
 	@param h is the hash type
 	@param P are input encoding parameter string (could be NULL)
 	@param F is input padded message, unpadded on output
-	@return 1 if OK, else 0
+	@return 0 if OK, else 1
  */
 extern int  OAEP_DECODE(int h,octet *P,octet *F);