diff --git a/src/dghv.rs b/src/dghv.rs
index cb73c79..c0e05d2 100644
--- a/src/dghv.rs
+++ b/src/dghv.rs
@@ -43,28 +43,28 @@ mod tests {
 
     #[test]
     fn test_encrypt_decrypt_bit() {
-        let eta = 64;
+        let eta = 10000;
         let key = generate_secret_key(eta);
 
         let bit = 0;
-        let ciphertext = encrypt_bit(bit, &key, 128, 61);
+        let ciphertext = encrypt_bit(bit, &key, 100, 100);
         let decrypted = decrypt_bit(&ciphertext, &key);
         assert_eq!(decrypted, bit);
 
         let bit = 1;
-        let ciphertext = encrypt_bit(bit, &key, 128, 61);
+        let ciphertext = encrypt_bit(bit, &key, 100, 100);
         let decrypted = decrypt_bit(&ciphertext, &key);
         assert_eq!(decrypted, bit);
     }
 
     #[test]
     fn test_multiple_encryptions_are_different() {
-        let eta = 64;
+        let eta = 10000;
         let key = generate_secret_key(eta);
 
         let bit = 1;
-        let c1 = encrypt_bit(bit, &key, 128, 61);
-        let c2 = encrypt_bit(bit, &key, 128, 61);
+        let c1 = encrypt_bit(bit, &key, 100, 100);
+        let c2 = encrypt_bit(bit, &key, 100, 100);
 
         assert_ne!(c1, c2);
         assert_eq!(decrypt_bit(&c1, &key), bit);
@@ -77,8 +77,8 @@ mod tests {
         let key = generate_secret_key(eta);
 
         for &(b1, b2) in &[(0, 0), (0, 1), (1, 0), (1, 1)] {
-            let c1 = encrypt_bit(b1, &key, 4096, 512);
-            let c2 = encrypt_bit(b2, &key, 4096, 512);
+            let c1 = encrypt_bit(b1, &key, 45, 45);
+            let c2 = encrypt_bit(b2, &key, 45, 45);
 
             let sum: Integer = c1.clone() + &c2;
             let product: Integer = c1 * c2;
diff --git a/src/dghv_asym.rs b/src/dghv_asym.rs
index f3355e3..883f35a 100644
--- a/src/dghv_asym.rs
+++ b/src/dghv_asym.rs
@@ -69,10 +69,9 @@ mod tests {
     #[test]
     fn test_key_generation_properties() {
         let eta: u32 = 10000;
-        let gamma: u32 = 11000;
         let theta: usize = 5;
-        let rho: u32 = 16;
-        let (sk, pk) = generate_keys(gamma, eta, rho, theta);
+        let rho: u32 = 100;
+        let (sk, pk) = generate_keys(rho, eta, rho, theta);
 
         assert_eq!(sk.p.significant_bits(), eta);
         assert!(sk.p.is_odd());
@@ -90,12 +89,11 @@ mod tests {
         use rayon::prelude::*;
 
         let eta: u32 = 10000;
-        let gamma: u32 = 11000;
         let theta: usize = 50;
-        let rho: u32 = 128;
+        let rho: u32 = 100;
 
         (0..=127).into_par_iter().for_each(|_| {
-            let (sk, pk) = generate_keys(gamma, eta, rho, theta);
+            let (sk, pk) = generate_keys(rho, eta, rho, theta);
             for &m in &[0u8, 1u8] {
                 let c = encrypt_bit_asym(m, &pk, rho);
                 let m2 = decrypt_bit(&c, &sk.p);
diff --git a/src/main.rs b/src/main.rs
index bee6522..80d7730 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,13 +5,13 @@ mod utils;
 use crate::dghv::{decrypt_bit, encrypt_bit, generate_secret_key};
 
 fn main() {
-    let eta = 10000;
+    let eta = 6400;
     let secret_key = generate_secret_key(eta);
 
     let bit = 1;
-    let ciphertext = encrypt_bit(bit, &secret_key, 10000, 512);
+    let ciphertext = encrypt_bit(bit, &secret_key, 80, 80);
     let decrypted = decrypt_bit(&ciphertext, &secret_key);
-    let opx2 = ciphertext.clone() * encrypt_bit(1, &secret_key, 10000, 512);
+    let opx2 = ciphertext.clone() * encrypt_bit(1, &secret_key, 80, 80);
     let decrypted_opx2 = decrypt_bit(&opx2, &secret_key);
 
     println!("clear bit (b): {}", bit);