diff --git a/backend_zk/src/main.rs b/backend_zk/src/main.rs
index eb0dcf1..490b758 100644
--- a/backend_zk/src/main.rs
+++ b/backend_zk/src/main.rs
@@ -479,6 +479,7 @@ fn main() {
         generate_random_parameters(circuit, &mut rng).expect("must generate parameters")
     };
 
+    // write vk in binary form
     let vk_file = File::create(PathBuf::from("./vk.key")).unwrap();
     parameters.vk.write(vk_file).unwrap();
 
@@ -489,19 +490,10 @@ fn main() {
         create_random_proof(circuit, &parameters, &mut rng).expect("must create a proof")
     };
 
+    // write proof in binary form
     let proof_file = File::create(PathBuf::from("./proof.key")).unwrap();
     proof.write(proof_file).unwrap();
 
-
-
-
-    let a : G1Affine = proof.a;
-    println!("proof a g1: {}", a);
-    println!("proof a g1 uncompressed: {}", a.into_uncompressed().as_ref());
-
-
-
-
     println!("public inputs: {}", public_inputs[0]);
 
     let is_valid = verify_proof(&prepared_vk, &proof, &public_inputs).expect("must verify a proof");
diff --git a/test_back_fluence/proof.bin b/test_back_fluence/proof.bin
new file mode 100644
index 0000000..645e0e8
--- /dev/null
+++ b/test_back_fluence/proof.bin
@@ -0,0 +1,2 @@
+<4{	€¤
+"ê¢Ò¼V".sOU½qw!ɆQˆr
]©¿çÛ¨{×7•!.ìçÕª;¨¡ò~4ȺŒ­JÇC.
Bxæ²[.1úB\|‘Ñî½®°ï"‹YTâ ÀŠ’\dR¹}›ƒ`�3ª“(J‹�ƒÖ¯eÁ
÷ëµì
\ No newline at end of file
diff --git a/test_back_fluence/proof2.bin b/test_back_fluence/proof2.bin
new file mode 100644
index 0000000..ef2298e
--- /dev/null
+++ b/test_back_fluence/proof2.bin
@@ -0,0 +1,2 @@
+<4{	€¤
+"ê¢Ò¼V".sOU½qw!ɆQˆr
]÷âÊbˆDË|,ÊÌŠ»I0Í"mÍ7ùè8`ùB¡w}
\ No newline at end of file
diff --git a/test_back_fluence/proving.key b/test_back_fluence/proving.key
deleted file mode 100644
index 672aea9..0000000
Binary files a/test_back_fluence/proving.key and /dev/null differ
diff --git a/test_back_fluence/src/main.rs b/test_back_fluence/src/main.rs
index 1b4ce1d..d9288ef 100644
--- a/test_back_fluence/src/main.rs
+++ b/test_back_fluence/src/main.rs
@@ -53,13 +53,22 @@ fn main() {
     use bellman::groth16::Proof;
     use bellman::groth16::VerifyingKey;
 
+    use bellman::pairing::{
+    Engine,
+    CurveAffine,
+    EncodedPoint
+    };
+
+
+    use crate::{
+        SynthesisError
+    };
+
+    use std::io::{self, Read};
+    use std::sync::Arc;
 
     // import verification key
 
-
-
-    self.alpha_g1.into_uncompressed().as_ref();
-
     //let vk_file = File::open(PathBuf::from("./verification.key")).unwrap();
     //let vk : VerifyingKey<Bn256> = VerifyingKey::read(vk_file).unwrap();
 
@@ -69,8 +78,49 @@ fn main() {
     //let prepared_vk = prepare_verifying_key(&vk);
 
     // import proof
-    //let proof_file = File::open(PathBuf::from("./proof.key")).unwrap();
-    //let proof : Proof<Bn256> = Proof::read(proof_file).unwrap(); 
+    let proof_file = File::open(PathBuf::from("./proof.bin")).unwrap();
+    let proof : Proof<Bn256> = Proof::read(proof_file).unwrap(); 
+
+    // export proof
+    let mut proof_file = File::create(PathBuf::from("./proof2.bin")).unwrap();
+    proof_file.write_all(proof.a.into_uncompressed().as_ref());
+    //proof_file.write_all(proof.b.into_compressed().as_ref());
+    //0x125c6452b97d9b83600e903313aa93284a8b8d8318050ed6af65c10df7ebb5ec
+    //let [u8] = 
+    //proof_file.write_all(proof.c.into_compressed().as_ref());
+
+    let mut proof_file = File::open(PathBuf::from("./proof2.bin")).unwrap();
+    //let proof : Proof<Bn256> = Proof::read(proof_file).unwrap();
+
+
+    let mut g1_repr = <bellman::pairing::bn256::G1Affine as CurveAffine>::Uncompressed::empty();
+    //let mut g2_repr = <bellman::pairing::bn256::G2Affine as CurveAffine>::Uncompressed::empty();
+
+    proof_file.read_exact(g1_repr.as_mut());
+    //let a = g1_repr.into_affine();
+    let a = g1_repr
+                .into_affine()
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+                .and_then(|e| if e.is_zero() {
+                    Err(io::Error::new(io::ErrorKind::InvalidData, "point at infinity"))
+                } else {
+                    Ok(e)
+                }).unwrap();
+    println!("!!! proof a g1: {}", a);
+
+
+     // write proof.a in hex form and binary form
+    let a : G1Affine = proof.a;
+    println!("proof a g1: {}", a);
+    println!("proof a g1 compressed: {:?}", a.into_compressed().as_ref());
+
+    let b : G2Affine = proof.b;
+    println!("proof b g2: {}", b);
+    println!("proof b g2 compressed: {:?}", b.into_compressed().as_ref());
+
+    let c : G1Affine = proof.c;
+    println!("proof c g1: {}", c);
+    println!("proof c g1 uncompressed: {:?}", c.into_compressed().as_ref());
 
     // import public inputs
     //let public_inputs = vec![];