diff --git a/Cargo.toml b/Cargo.toml
index 166b2ce..91823d3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,7 +16,6 @@ readme        = "README.md"
 keywords      = ["merkle", "merkle-tree"]
 categories    = ["data-structures", "cryptography"]
 
-
 [dependencies]
 ring = "^0.16.1"
 protobuf = { version = "^2.8.0", optional = true }
diff --git a/benches/lib.rs b/benches/lib.rs
index 6718cf7..74e9568 100644
--- a/benches/lib.rs
+++ b/benches/lib.rs
@@ -1,128 +1,128 @@
-#![feature(test)]
-#![feature(rand)]
+// #![feature(test)]
+// #![feature(rand)]
 
-extern crate rand;
-extern crate test;
+// extern crate rand;
+// extern crate test;
 
-extern crate merkle;
-extern crate ring;
+// extern crate merkle;
+// extern crate ring;
 
-use rand::Rng;
-use test::Bencher;
+// use rand::Rng;
+// use test::Bencher;
 
-use ring::digest::{Algorithm, SHA512};
+// use ring::digest::{Algorithm, SHA512};
 
-use merkle::MerkleTree;
+// use merkle::MerkleTree;
 
-#[allow(non_upper_case_globals)]
-static digest: &'static Algorithm = &SHA512;
+// #[allow(non_upper_case_globals)]
+// static digest: &'static Algorithm = &SHA512;
 
-#[bench]
-fn bench_small_str_tree(b: &mut Bencher) {
-    let values = vec!["one", "two", "three", "four"];
+// #[bench]
+// fn bench_small_str_tree(b: &mut Bencher) {
+//     let values = vec!["one", "two", "three", "four"];
 
-    b.iter(|| MerkleTree::from_vec(digest, values.clone()));
-}
+//     b.iter(|| MerkleTree::from_vec(digest, values.clone()));
+// }
 
-#[bench]
-fn bench_small_str_proof_gen(b: &mut Bencher) {
-    let values = vec!["one", "two", "three", "four"];
-    let tree = MerkleTree::from_vec(digest, values.clone());
+// #[bench]
+// fn bench_small_str_proof_gen(b: &mut Bencher) {
+//     let values = vec!["one", "two", "three", "four"];
+//     let tree = MerkleTree::from_vec(digest, values.clone());
 
-    b.iter(|| {
-        for value in &values {
-            let proof = tree.gen_proof(value);
-            test::black_box(proof);
-        }
-    });
-}
+//     b.iter(|| {
+//         for value in &values {
+//             let proof = tree.gen_proof(value);
+//             test::black_box(proof);
+//         }
+//     });
+// }
 
-#[bench]
-fn bench_small_str_proof_check(b: &mut Bencher) {
-    let values = vec!["one", "two", "three", "four"];
-    let tree = MerkleTree::from_vec(digest, values.clone());
-    let proofs = values
-        .iter()
-        .map(|v| tree.gen_proof(v).unwrap())
-        .collect::<Vec<_>>();
+// #[bench]
+// fn bench_small_str_proof_check(b: &mut Bencher) {
+//     let values = vec!["one", "two", "three", "four"];
+//     let tree = MerkleTree::from_vec(digest, values.clone());
+//     let proofs = values
+//         .iter()
+//         .map(|v| tree.gen_proof(v).unwrap())
+//         .collect::<Vec<_>>();
 
-    b.iter(|| {
-        for proof in &proofs {
-            test::black_box(proof.validate(tree.root_hash()));
-        }
-    });
-}
+//     b.iter(|| {
+//         for proof in &proofs {
+//             test::black_box(proof.validate(tree.root_hash()));
+//         }
+//     });
+// }
 
-#[bench]
-fn bench_big_rnd_tree(b: &mut Bencher) {
-    let mut values = vec![vec![0u8; 256]; 160];
-    let mut rng = rand::IsaacRng::new_unseeded();
+// #[bench]
+// fn bench_big_rnd_tree(b: &mut Bencher) {
+//     let mut values = vec![vec![0u8; 256]; 160];
+//     let mut rng = rand::IsaacRng::new_unseeded();
 
-    for mut v in &mut values {
-        rng.fill_bytes(&mut v);
-    }
+//     for mut v in &mut values {
+//         rng.fill_bytes(&mut v);
+//     }
 
-    b.iter(|| {
-        let tree = MerkleTree::from_vec(digest, values.clone());
-        test::black_box(tree)
-    });
-}
+//     b.iter(|| {
+//         let tree = MerkleTree::from_vec(digest, values.clone());
+//         test::black_box(tree)
+//     });
+// }
 
-#[bench]
-fn bench_big_rnd_proof_gen(b: &mut Bencher) {
-    let mut values = vec![vec![0u8; 256]; 160];
-    let mut rng = rand::IsaacRng::new_unseeded();
+// #[bench]
+// fn bench_big_rnd_proof_gen(b: &mut Bencher) {
+//     let mut values = vec![vec![0u8; 256]; 160];
+//     let mut rng = rand::IsaacRng::new_unseeded();
 
-    for mut v in &mut values {
-        rng.fill_bytes(&mut v);
-    }
+//     for mut v in &mut values {
+//         rng.fill_bytes(&mut v);
+//     }
 
-    let tree = MerkleTree::from_vec(digest, values.clone());
+//     let tree = MerkleTree::from_vec(digest, values.clone());
 
-    b.iter(|| {
-        for value in &values {
-            let proof = tree.gen_proof(value.clone());
-            test::black_box(proof);
-        }
-    });
-}
+//     b.iter(|| {
+//         for value in &values {
+//             let proof = tree.gen_proof(value.clone());
+//             test::black_box(proof);
+//         }
+//     });
+// }
 
-#[bench]
-fn bench_big_rnd_proof_check(b: &mut Bencher) {
-    let mut values = vec![vec![0u8; 256]; 160];
-    let mut rng = rand::IsaacRng::new_unseeded();
+// #[bench]
+// fn bench_big_rnd_proof_check(b: &mut Bencher) {
+//     let mut values = vec![vec![0u8; 256]; 160];
+//     let mut rng = rand::IsaacRng::new_unseeded();
 
-    for mut v in &mut values {
-        rng.fill_bytes(&mut v);
-    }
+//     for mut v in &mut values {
+//         rng.fill_bytes(&mut v);
+//     }
 
-    let tree = MerkleTree::from_vec(digest, values.clone());
-    let proofs = values
-        .into_iter()
-        .map(|v| tree.gen_proof(v).unwrap())
-        .collect::<Vec<_>>();
+//     let tree = MerkleTree::from_vec(digest, values.clone());
+//     let proofs = values
+//         .into_iter()
+//         .map(|v| tree.gen_proof(v).unwrap())
+//         .collect::<Vec<_>>();
 
-    b.iter(|| {
-        for proof in &proofs {
-            test::black_box(proof.validate(tree.root_hash()));
-        }
-    });
-}
+//     b.iter(|| {
+//         for proof in &proofs {
+//             test::black_box(proof.validate(tree.root_hash()));
+//         }
+//     });
+// }
 
-#[bench]
-fn bench_big_rnd_iter(b: &mut Bencher) {
-    let mut values = vec![vec![0u8; 256]; 160];
-    let mut rng = rand::IsaacRng::new_unseeded();
+// #[bench]
+// fn bench_big_rnd_iter(b: &mut Bencher) {
+//     let mut values = vec![vec![0u8; 256]; 160];
+//     let mut rng = rand::IsaacRng::new_unseeded();
 
-    for mut v in &mut values {
-        rng.fill_bytes(&mut v);
-    }
+//     for mut v in &mut values {
+//         rng.fill_bytes(&mut v);
+//     }
 
-    let tree = MerkleTree::from_vec(digest, values.clone());
+//     let tree = MerkleTree::from_vec(digest, values.clone());
 
-    b.iter(|| {
-        for value in &tree {
-            test::black_box(value);
-        }
-    });
-}
+//     b.iter(|| {
+//         for value in &tree {
+//             test::black_box(value);
+//         }
+//     });
+// }
diff --git a/src/proof.rs b/src/proof.rs
index ab74a08..d4dfb31 100644
--- a/src/proof.rs
+++ b/src/proof.rs
@@ -75,11 +75,12 @@ mod algorithm_serde {
                     serde_json::ser::PrettyFormatter::new(),
                 );
 
-                serialize(alg, &mut serializer).expect(&format!("{:?}", alg));
+                serialize(alg, &mut serializer).unwrap_or_else(|_| panic!("{:?}", alg));
+
                 let alg_ = deserialize(&mut serde_json::Deserializer::from_slice(
                     &serializer.into_inner()[..],
                 ))
-                .expect(&format!("{:?}", alg));
+                .unwrap_or_else(|_| panic!("{:?}", alg));
 
                 assert_eq!(*alg, alg_);
             }
@@ -92,7 +93,7 @@ mod algorithm_serde {
             {
                 let alg_str = "\"BLAKE2b\"";
                 let mut deserializer = serde_json::Deserializer::from_str(alg_str);
-                let _ = deserialize(&mut deserializer).expect(&format!("{:?}", alg_str));
+                let _ = deserialize(&mut deserializer).unwrap_or_else(|_| panic!("{:?}", alg_str));
             }
         }
     }
diff --git a/src/tests.rs b/src/tests.rs
index c1e1c47..30ab19e 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -154,7 +154,7 @@ fn test_wrong_proof() {
 fn test_nth_proof() {
     // Calculation depends on the total count. Try a few numbers: odd, even, powers of two...
     for &count in &[1, 2, 3, 10, 15, 16, 17, 22] {
-        let values = (1..(count + 1)).map(|x| vec![x as u8]).collect::<Vec<_>>();
+        let values = (1..=count).map(|x| vec![x as u8]).collect::<Vec<_>>();
         let tree = MerkleTree::from_vec(digest, values.clone());
         let root_hash = tree.root_hash();