diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index b8ac651..b14f8d0 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -4,7 +4,7 @@ on:
   push:
     branches: [ '*' ]
   pull_request:
-    branches: [ main, develop ]
+    branches: [ '*' ]
 
 env:
   CARGO_TERM_COLOR: always
diff --git a/Cargo.toml b/Cargo.toml
index a986607..35b2e72 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,6 +6,7 @@ name = "curve25519-dalek"
 # - update README if required by semver
 # - if README was updated, also update module documentation in src/lib.rs
 version = "4.0.0-pre.2"
+edition = "2021"
 authors = ["Isis Lovecruft <isis@patternsinthevoid.net>",
            "Henry de Valence <hdevalence@hdevalence.ca>"]
 readme = "README.md"
diff --git a/benches/dalek_benchmarks.rs b/benches/dalek_benchmarks.rs
index 308545c..cd940ae 100644
--- a/benches/dalek_benchmarks.rs
+++ b/benches/dalek_benchmarks.rs
@@ -1,18 +1,12 @@
 #![allow(non_snake_case)]
 
-extern crate rand;
 use rand::rngs::OsRng;
 use rand::thread_rng;
 
-#[macro_use]
-extern crate criterion;
-
 use criterion::measurement::Measurement;
 use criterion::BatchSize;
 use criterion::Criterion;
-use criterion::{BenchmarkGroup, BenchmarkId};
-
-extern crate curve25519_dalek;
+use criterion::{criterion_group, criterion_main, BenchmarkGroup, BenchmarkId};
 
 use curve25519_dalek::constants;
 use curve25519_dalek::scalar::Scalar;
diff --git a/src/backend/serial/curve_models/mod.rs b/src/backend/serial/curve_models/mod.rs
index 9d10d92..7b08469 100644
--- a/src/backend/serial/curve_models/mod.rs
+++ b/src/backend/serial/curve_models/mod.rs
@@ -131,11 +131,11 @@ use subtle::ConditionallySelectable;
 
 use zeroize::Zeroize;
 
-use constants;
+use crate::constants;
 
-use edwards::EdwardsPoint;
-use field::FieldElement;
-use traits::ValidityCheck;
+use crate::edwards::EdwardsPoint;
+use crate::field::FieldElement;
+use crate::traits::ValidityCheck;
 
 // ------------------------------------------------------------------------
 // Internal point representations
@@ -219,7 +219,7 @@ impl Zeroize for ProjectiveNielsPoint {
 // Constructors
 // ------------------------------------------------------------------------
 
-use traits::Identity;
+use crate::traits::Identity;
 
 impl Identity for ProjectivePoint {
     fn identity() -> ProjectivePoint {
diff --git a/src/backend/serial/scalar_mul/pippenger.rs b/src/backend/serial/scalar_mul/pippenger.rs
index 575291d..39d7ae1 100644
--- a/src/backend/serial/scalar_mul/pippenger.rs
+++ b/src/backend/serial/scalar_mul/pippenger.rs
@@ -13,12 +13,12 @@
 
 use core::borrow::Borrow;
 
-use edwards::EdwardsPoint;
-use scalar::Scalar;
-use traits::VartimeMultiscalarMul;
+use crate::edwards::EdwardsPoint;
+use crate::scalar::Scalar;
+use crate::traits::VartimeMultiscalarMul;
 
 #[allow(unused_imports)]
-use prelude::*;
+use crate::prelude::*;
 
 /// Implements a version of Pippenger's algorithm.
 ///
@@ -71,7 +71,7 @@ impl VartimeMultiscalarMul for Pippenger {
         I::Item: Borrow<Scalar>,
         J: IntoIterator<Item = Option<EdwardsPoint>>,
     {
-        use traits::Identity;
+        use crate::traits::Identity;
 
         let mut scalars = scalars.into_iter();
         let size = scalars.by_ref().size_hint().0;
@@ -165,8 +165,8 @@ impl VartimeMultiscalarMul for Pippenger {
 #[cfg(test)]
 mod test {
     use super::*;
-    use constants;
-    use scalar::Scalar;
+    use crate::constants;
+    use crate::scalar::Scalar;
 
     #[test]
     fn test_vartime_pippenger() {
diff --git a/src/backend/serial/scalar_mul/precomputed_straus.rs b/src/backend/serial/scalar_mul/precomputed_straus.rs
index 97f5e86..fee21c2 100644
--- a/src/backend/serial/scalar_mul/precomputed_straus.rs
+++ b/src/backend/serial/scalar_mul/precomputed_straus.rs
@@ -13,17 +13,17 @@
 
 use core::borrow::Borrow;
 
-use backend::serial::curve_models::{
+use crate::backend::serial::curve_models::{
     AffineNielsPoint, CompletedPoint, ProjectiveNielsPoint, ProjectivePoint,
 };
-use edwards::EdwardsPoint;
-use scalar::Scalar;
-use traits::Identity;
-use traits::VartimePrecomputedMultiscalarMul;
-use window::{NafLookupTable5, NafLookupTable8};
+use crate::edwards::EdwardsPoint;
+use crate::scalar::Scalar;
+use crate::traits::Identity;
+use crate::traits::VartimePrecomputedMultiscalarMul;
+use crate::window::{NafLookupTable5, NafLookupTable8};
 
 #[allow(unused_imports)]
-use prelude::*;
+use crate::prelude::*;
 
 pub struct VartimePrecomputedStraus {
     static_lookup_tables: Vec<NafLookupTable8<AffineNielsPoint>>,
diff --git a/src/backend/serial/scalar_mul/straus.rs b/src/backend/serial/scalar_mul/straus.rs
index a361df5..378751b 100644
--- a/src/backend/serial/scalar_mul/straus.rs
+++ b/src/backend/serial/scalar_mul/straus.rs
@@ -15,13 +15,13 @@
 
 use core::borrow::Borrow;
 
-use edwards::EdwardsPoint;
-use scalar::Scalar;
-use traits::MultiscalarMul;
-use traits::VartimeMultiscalarMul;
+use crate::edwards::EdwardsPoint;
+use crate::scalar::Scalar;
+use crate::traits::MultiscalarMul;
+use crate::traits::VartimeMultiscalarMul;
 
 #[allow(unused_imports)]
-use prelude::*;
+use crate::prelude::*;
 
 /// Perform multiscalar multiplication by the interleaved window
 /// method, also known as Straus' method (since it was apparently
@@ -109,9 +109,9 @@ impl MultiscalarMul for Straus {
     {
         use zeroize::Zeroizing;
 
-        use backend::serial::curve_models::ProjectiveNielsPoint;
-        use window::LookupTable;
-        use traits::Identity;
+        use crate::backend::serial::curve_models::ProjectiveNielsPoint;
+        use crate::window::LookupTable;
+        use crate::traits::Identity;
 
         let lookup_tables: Vec<_> = points
             .into_iter()
@@ -161,9 +161,9 @@ impl VartimeMultiscalarMul for Straus {
         I::Item: Borrow<Scalar>,
         J: IntoIterator<Item = Option<EdwardsPoint>>,
     {
-        use backend::serial::curve_models::{CompletedPoint, ProjectiveNielsPoint, ProjectivePoint};
-        use window::NafLookupTable5;
-        use traits::Identity;
+        use crate::backend::serial::curve_models::{CompletedPoint, ProjectiveNielsPoint, ProjectivePoint};
+        use crate::window::NafLookupTable5;
+        use crate::traits::Identity;
 
         let nafs: Vec<_> = scalars
             .into_iter()
diff --git a/src/backend/serial/scalar_mul/variable_base.rs b/src/backend/serial/scalar_mul/variable_base.rs
index a4ff2ed..9026607 100644
--- a/src/backend/serial/scalar_mul/variable_base.rs
+++ b/src/backend/serial/scalar_mul/variable_base.rs
@@ -1,10 +1,10 @@
 #![allow(non_snake_case)]
 
-use traits::Identity;
-use scalar::Scalar;
-use edwards::EdwardsPoint;
-use backend::serial::curve_models::ProjectiveNielsPoint;
-use window::LookupTable;
+use crate::traits::Identity;
+use crate::scalar::Scalar;
+use crate::edwards::EdwardsPoint;
+use crate::backend::serial::curve_models::ProjectiveNielsPoint;
+use crate::window::LookupTable;
 
 /// Perform constant-time, variable-base scalar multiplication.
 pub(crate) fn mul(point: &EdwardsPoint, scalar: &Scalar) -> EdwardsPoint {
diff --git a/src/backend/serial/scalar_mul/vartime_double_base.rs b/src/backend/serial/scalar_mul/vartime_double_base.rs
index 03517f9..0486d9e 100644
--- a/src/backend/serial/scalar_mul/vartime_double_base.rs
+++ b/src/backend/serial/scalar_mul/vartime_double_base.rs
@@ -10,12 +10,12 @@
 // - Henry de Valence <hdevalence@hdevalence.ca>
 #![allow(non_snake_case)]
 
-use constants;
-use traits::Identity;
-use scalar::Scalar;
-use edwards::EdwardsPoint;
-use backend::serial::curve_models::{ProjectiveNielsPoint, ProjectivePoint};
-use window::NafLookupTable5;
+use crate::backend::serial::curve_models::{ProjectiveNielsPoint, ProjectivePoint};
+use crate::constants;
+use crate::edwards::EdwardsPoint;
+use crate::scalar::Scalar;
+use crate::traits::Identity;
+use crate::window::NafLookupTable5;
 
 /// Compute \\(aA + bB\\) in variable time, where \\(B\\) is the Ed25519 basepoint.
 pub fn mul(a: &Scalar, A: &EdwardsPoint, b: &Scalar) -> EdwardsPoint {
diff --git a/src/backend/serial/u32/constants.rs b/src/backend/serial/u32/constants.rs
index af509cf..c795658 100644
--- a/src/backend/serial/u32/constants.rs
+++ b/src/backend/serial/u32/constants.rs
@@ -13,15 +13,16 @@
 //! and useful field elements like `sqrt(-1)`), as well as
 //! lookup tables of pre-computed points.
 
-use backend::serial::curve_models::AffineNielsPoint;
 use super::field::FieldElement2625;
 use super::scalar::Scalar29;
-use edwards::{EdwardsBasepointTable, EdwardsPoint};
-use window::{LookupTable, NafLookupTable8};
+use crate::backend::serial::curve_models::AffineNielsPoint;
+use crate::edwards::{EdwardsBasepointTable, EdwardsPoint};
+use crate::window::{LookupTable, NafLookupTable8};
 
 /// The value of minus one, equal to `-&FieldElement::one()`
 pub(crate) const MINUS_ONE: FieldElement2625 = FieldElement2625([
-    67108844, 33554431, 67108863, 33554431, 67108863, 33554431, 67108863, 33554431, 67108863, 33554431
+    67108844, 33554431, 67108863, 33554431, 67108863, 33554431, 67108863, 33554431, 67108863,
+    33554431,
 ]);
 
 /// Edwards `d` value, equal to `-121665/121666 mod p`.
@@ -35,13 +36,14 @@ pub(crate) const EDWARDS_D2: FieldElement2625 = FieldElement2625([
 ]);
 
 /// One minus edwards `d` value squared, equal to `(1 - (-121665/121666) mod p) pow 2`
-pub(crate) const ONE_MINUS_EDWARDS_D_SQUARED: FieldElement2625 =  FieldElement2625([
-    6275446, 16937061, 44170319, 29780721, 11667076, 7397348, 39186143, 1766194, 42675006, 672202
+pub(crate) const ONE_MINUS_EDWARDS_D_SQUARED: FieldElement2625 = FieldElement2625([
+    6275446, 16937061, 44170319, 29780721, 11667076, 7397348, 39186143, 1766194, 42675006, 672202,
 ]);
 
 /// Edwards `d` value minus one squared, equal to `(((-121665/121666) mod p) - 1) pow 2`
-pub(crate) const EDWARDS_D_MINUS_ONE_SQUARED: FieldElement2625 =  FieldElement2625([
-    15551776, 22456977, 53683765, 23429360, 55212328, 10178283, 40474537, 4729243, 61826754, 23438029
+pub(crate) const EDWARDS_D_MINUS_ONE_SQUARED: FieldElement2625 = FieldElement2625([
+    15551776, 22456977, 53683765, 23429360, 55212328, 10178283, 40474537, 4729243, 61826754,
+    23438029,
 ]);
 
 /// `= sqrt(a*d - 1)`, where `a = -1 (mod p)`, `d` are the Edwards curve parameters.
@@ -73,7 +75,8 @@ pub(crate) const MONTGOMERY_A: FieldElement2625 =
 /// `MONTGOMERY_A_NEG` is equal to -486662. (This is used internally within the
 /// Elligator map.)
 pub(crate) const MONTGOMERY_A_NEG: FieldElement2625 = FieldElement2625([
-    66622183, 33554431, 67108863, 33554431, 67108863, 33554431, 67108863, 33554431, 67108863, 33554431,
+    66622183, 33554431, 67108863, 33554431, 67108863, 33554431, 67108863, 33554431, 67108863,
+    33554431,
 ]);
 
 /// `L` is the order of base point, i.e. 2^252 +
diff --git a/src/backend/serial/u32/scalar.rs b/src/backend/serial/u32/scalar.rs
index 8dd54bd..9b74889 100644
--- a/src/backend/serial/u32/scalar.rs
+++ b/src/backend/serial/u32/scalar.rs
@@ -15,10 +15,10 @@ use core::ops::{Index, IndexMut};
 
 use zeroize::Zeroize;
 
-use constants;
+use crate::constants;
 
 /// The `Scalar29` struct represents an element in ℤ/lℤ as 9 29-bit limbs
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
 pub struct Scalar29(pub [u32; 9]);
 
 impl Debug for Scalar29 {
@@ -55,7 +55,7 @@ fn m(x: u32, y: u32) -> u64 {
 impl Scalar29 {
     /// Return the zero scalar.
     pub fn zero() -> Scalar29 {
-        Scalar29([0,0,0,0,0,0,0,0,0])
+        Scalar29([0, 0, 0, 0, 0, 0, 0, 0, 0])
     }
 
     /// Unpack a 32 byte / 256 bit scalar into 9 29-bit limbs.
@@ -71,15 +71,15 @@ impl Scalar29 {
         let top_mask = (1u32 << 24) - 1;
         let mut s = Scalar29::zero();
 
-        s[ 0] =   words[0]                            & mask;
-        s[ 1] = ((words[0] >> 29) | (words[1] <<  3)) & mask;
-        s[ 2] = ((words[1] >> 26) | (words[2] <<  6)) & mask;
-        s[ 3] = ((words[2] >> 23) | (words[3] <<  9)) & mask;
-        s[ 4] = ((words[3] >> 20) | (words[4] << 12)) & mask;
-        s[ 5] = ((words[4] >> 17) | (words[5] << 15)) & mask;
-        s[ 6] = ((words[5] >> 14) | (words[6] << 18)) & mask;
-        s[ 7] = ((words[6] >> 11) | (words[7] << 21)) & mask;
-        s[ 8] =  (words[7] >>  8)                     & top_mask;
+        s[0] = words[0] & mask;
+        s[1] = ((words[0] >> 29) | (words[1] << 3)) & mask;
+        s[2] = ((words[1] >> 26) | (words[2] << 6)) & mask;
+        s[3] = ((words[2] >> 23) | (words[3] << 9)) & mask;
+        s[4] = ((words[3] >> 20) | (words[4] << 12)) & mask;
+        s[5] = ((words[4] >> 17) | (words[5] << 15)) & mask;
+        s[6] = ((words[5] >> 14) | (words[6] << 18)) & mask;
+        s[7] = ((words[6] >> 11) | (words[7] << 21)) & mask;
+        s[8] = (words[7] >> 8) & top_mask;
 
         s
     }
@@ -97,26 +97,26 @@ impl Scalar29 {
         let mut lo = Scalar29::zero();
         let mut hi = Scalar29::zero();
 
-        lo[0] =   words[ 0]                             & mask;
-        lo[1] = ((words[ 0] >> 29) | (words[ 1] <<  3)) & mask;
-        lo[2] = ((words[ 1] >> 26) | (words[ 2] <<  6)) & mask;
-        lo[3] = ((words[ 2] >> 23) | (words[ 3] <<  9)) & mask;
-        lo[4] = ((words[ 3] >> 20) | (words[ 4] << 12)) & mask;
-        lo[5] = ((words[ 4] >> 17) | (words[ 5] << 15)) & mask;
-        lo[6] = ((words[ 5] >> 14) | (words[ 6] << 18)) & mask;
-        lo[7] = ((words[ 6] >> 11) | (words[ 7] << 21)) & mask;
-        lo[8] = ((words[ 7] >>  8) | (words[ 8] << 24)) & mask;
-        hi[0] = ((words[ 8] >>  5) | (words[ 9] << 27)) & mask;
-        hi[1] =  (words[ 9] >>  2)                      & mask;
-        hi[2] = ((words[ 9] >> 31) | (words[10] <<  1)) & mask;
-        hi[3] = ((words[10] >> 28) | (words[11] <<  4)) & mask;
-        hi[4] = ((words[11] >> 25) | (words[12] <<  7)) & mask;
+        lo[0] = words[0] & mask;
+        lo[1] = ((words[0] >> 29) | (words[1] << 3)) & mask;
+        lo[2] = ((words[1] >> 26) | (words[2] << 6)) & mask;
+        lo[3] = ((words[2] >> 23) | (words[3] << 9)) & mask;
+        lo[4] = ((words[3] >> 20) | (words[4] << 12)) & mask;
+        lo[5] = ((words[4] >> 17) | (words[5] << 15)) & mask;
+        lo[6] = ((words[5] >> 14) | (words[6] << 18)) & mask;
+        lo[7] = ((words[6] >> 11) | (words[7] << 21)) & mask;
+        lo[8] = ((words[7] >> 8) | (words[8] << 24)) & mask;
+        hi[0] = ((words[8] >> 5) | (words[9] << 27)) & mask;
+        hi[1] = (words[9] >> 2) & mask;
+        hi[2] = ((words[9] >> 31) | (words[10] << 1)) & mask;
+        hi[3] = ((words[10] >> 28) | (words[11] << 4)) & mask;
+        hi[4] = ((words[11] >> 25) | (words[12] << 7)) & mask;
         hi[5] = ((words[12] >> 22) | (words[13] << 10)) & mask;
         hi[6] = ((words[13] >> 19) | (words[14] << 13)) & mask;
         hi[7] = ((words[14] >> 16) | (words[15] << 16)) & mask;
-        hi[8] =   words[15] >> 13                             ;
+        hi[8] = words[15] >> 13;
 
-        lo = Scalar29::montgomery_mul(&lo, &constants::R);  // (lo * R) / R = lo
+        lo = Scalar29::montgomery_mul(&lo, &constants::R); // (lo * R) / R = lo
         hi = Scalar29::montgomery_mul(&hi, &constants::RR); // (hi * R^2) / R = hi * R
 
         Scalar29::add(&hi, &lo) // (hi * R) + lo
@@ -126,38 +126,38 @@ impl Scalar29 {
     pub fn to_bytes(&self) -> [u8; 32] {
         let mut s = [0u8; 32];
 
-        s[0]  =  (self.0[ 0] >>  0)                      as u8;
-        s[1]  =  (self.0[ 0] >>  8)                      as u8;
-        s[2]  =  (self.0[ 0] >> 16)                      as u8;
-        s[3]  = ((self.0[ 0] >> 24) | (self.0[ 1] << 5)) as u8;
-        s[4]  =  (self.0[ 1] >>  3)                      as u8;
-        s[5]  =  (self.0[ 1] >> 11)                      as u8;
-        s[6]  =  (self.0[ 1] >> 19)                      as u8;
-        s[7]  = ((self.0[ 1] >> 27) | (self.0[ 2] << 2)) as u8;
-        s[8]  =  (self.0[ 2] >>  6)                      as u8;
-        s[9]  =  (self.0[ 2] >> 14)                      as u8;
-        s[10] = ((self.0[ 2] >> 22) | (self.0[ 3] << 7)) as u8;
-        s[11] =  (self.0[ 3] >>  1)                      as u8;
-        s[12] =  (self.0[ 3] >>  9)                      as u8;
-        s[13] =  (self.0[ 3] >> 17)                      as u8;
-        s[14] = ((self.0[ 3] >> 25) | (self.0[ 4] << 4)) as u8;
-        s[15] =  (self.0[ 4] >>  4)                      as u8;
-        s[16] =  (self.0[ 4] >> 12)                      as u8;
-        s[17] =  (self.0[ 4] >> 20)                      as u8;
-        s[18] = ((self.0[ 4] >> 28) | (self.0[ 5] << 1)) as u8;
-        s[19] =  (self.0[ 5] >>  7)                      as u8;
-        s[20] =  (self.0[ 5] >> 15)                      as u8;
-        s[21] = ((self.0[ 5] >> 23) | (self.0[ 6] << 6)) as u8;
-        s[22] =  (self.0[ 6] >>  2)                      as u8;
-        s[23] =  (self.0[ 6] >> 10)                      as u8;
-        s[24] =  (self.0[ 6] >> 18)                      as u8;
-        s[25] = ((self.0[ 6] >> 26) | (self.0[ 7] << 3)) as u8;
-        s[26] =  (self.0[ 7] >>  5)                      as u8;
-        s[27] =  (self.0[ 7] >> 13)                      as u8;
-        s[28] =  (self.0[ 7] >> 21)                      as u8;
-        s[29] =  (self.0[ 8] >>  0)                      as u8;
-        s[30] =  (self.0[ 8] >>  8)                      as u8;
-        s[31] =  (self.0[ 8] >> 16)                      as u8;
+        s[0] = (self.0[0] >> 0) as u8;
+        s[1] = (self.0[0] >> 8) as u8;
+        s[2] = (self.0[0] >> 16) as u8;
+        s[3] = ((self.0[0] >> 24) | (self.0[1] << 5)) as u8;
+        s[4] = (self.0[1] >> 3) as u8;
+        s[5] = (self.0[1] >> 11) as u8;
+        s[6] = (self.0[1] >> 19) as u8;
+        s[7] = ((self.0[1] >> 27) | (self.0[2] << 2)) as u8;
+        s[8] = (self.0[2] >> 6) as u8;
+        s[9] = (self.0[2] >> 14) as u8;
+        s[10] = ((self.0[2] >> 22) | (self.0[3] << 7)) as u8;
+        s[11] = (self.0[3] >> 1) as u8;
+        s[12] = (self.0[3] >> 9) as u8;
+        s[13] = (self.0[3] >> 17) as u8;
+        s[14] = ((self.0[3] >> 25) | (self.0[4] << 4)) as u8;
+        s[15] = (self.0[4] >> 4) as u8;
+        s[16] = (self.0[4] >> 12) as u8;
+        s[17] = (self.0[4] >> 20) as u8;
+        s[18] = ((self.0[4] >> 28) | (self.0[5] << 1)) as u8;
+        s[19] = (self.0[5] >> 7) as u8;
+        s[20] = (self.0[5] >> 15) as u8;
+        s[21] = ((self.0[5] >> 23) | (self.0[6] << 6)) as u8;
+        s[22] = (self.0[6] >> 2) as u8;
+        s[23] = (self.0[6] >> 10) as u8;
+        s[24] = (self.0[6] >> 18) as u8;
+        s[25] = ((self.0[6] >> 26) | (self.0[7] << 3)) as u8;
+        s[26] = (self.0[7] >> 5) as u8;
+        s[27] = (self.0[7] >> 13) as u8;
+        s[28] = (self.0[7] >> 21) as u8;
+        s[29] = (self.0[8] >> 0) as u8;
+        s[30] = (self.0[8] >> 8) as u8;
+        s[31] = (self.0[8] >> 16) as u8;
 
         s
     }
@@ -205,57 +205,51 @@ impl Scalar29 {
     ///
     /// This is implemented with a one-level refined Karatsuba decomposition
     #[inline(always)]
-    pub (crate) fn mul_internal(a: &Scalar29, b: &Scalar29) -> [u64; 17] {
+    pub(crate) fn mul_internal(a: &Scalar29, b: &Scalar29) -> [u64; 17] {
         let mut z = [0u64; 17];
 
-        z[0] = m(a[0],b[0]);                                                             // c00
-        z[1] = m(a[0],b[1]) + m(a[1],b[0]);                                              // c01
-        z[2] = m(a[0],b[2]) + m(a[1],b[1]) + m(a[2],b[0]);                               // c02
-        z[3] = m(a[0],b[3]) + m(a[1],b[2]) + m(a[2],b[1]) + m(a[3],b[0]);                // c03
-        z[4] = m(a[0],b[4]) + m(a[1],b[3]) + m(a[2],b[2]) + m(a[3],b[1]) + m(a[4],b[0]); // c04
-        z[5] =                m(a[1],b[4]) + m(a[2],b[3]) + m(a[3],b[2]) + m(a[4],b[1]); // c05
-        z[6] =                               m(a[2],b[4]) + m(a[3],b[3]) + m(a[4],b[2]); // c06
-        z[7] =                                              m(a[3],b[4]) + m(a[4],b[3]); // c07
-        z[8] =                                                            (m(a[4],b[4])).wrapping_sub(z[3]); // c08 - c03
+        z[0] = m(a[0], b[0]); // c00
+        z[1] = m(a[0], b[1]) + m(a[1], b[0]); // c01
+        z[2] = m(a[0], b[2]) + m(a[1], b[1]) + m(a[2], b[0]); // c02
+        z[3] = m(a[0], b[3]) + m(a[1], b[2]) + m(a[2], b[1]) + m(a[3], b[0]); // c03
+        z[4] = m(a[0], b[4]) + m(a[1], b[3]) + m(a[2], b[2]) + m(a[3], b[1]) + m(a[4], b[0]); // c04
+        z[5] = m(a[1], b[4]) + m(a[2], b[3]) + m(a[3], b[2]) + m(a[4], b[1]); // c05
+        z[6] = m(a[2], b[4]) + m(a[3], b[3]) + m(a[4], b[2]); // c06
+        z[7] = m(a[3], b[4]) + m(a[4], b[3]); // c07
+        z[8] = (m(a[4], b[4])).wrapping_sub(z[3]); // c08 - c03
 
-        z[10] = z[5].wrapping_sub(m(a[5],b[5]));                                             // c05mc10
-        z[11] = z[6].wrapping_sub(m(a[5],b[6]) + m(a[6],b[5]));                              // c06mc11
-        z[12] = z[7].wrapping_sub(m(a[5],b[7]) + m(a[6],b[6]) + m(a[7],b[5]));               // c07mc12
-        z[13] =                   m(a[5],b[8]) + m(a[6],b[7]) + m(a[7],b[6]) + m(a[8],b[5]); // c13
-        z[14] =                                  m(a[6],b[8]) + m(a[7],b[7]) + m(a[8],b[6]); // c14
-        z[15] =                                                 m(a[7],b[8]) + m(a[8],b[7]); // c15
-        z[16] =                                                                m(a[8],b[8]); // c16
+        z[10] = z[5].wrapping_sub(m(a[5], b[5])); // c05mc10
+        z[11] = z[6].wrapping_sub(m(a[5], b[6]) + m(a[6], b[5])); // c06mc11
+        z[12] = z[7].wrapping_sub(m(a[5], b[7]) + m(a[6], b[6]) + m(a[7], b[5])); // c07mc12
+        z[13] = m(a[5], b[8]) + m(a[6], b[7]) + m(a[7], b[6]) + m(a[8], b[5]); // c13
+        z[14] = m(a[6], b[8]) + m(a[7], b[7]) + m(a[8], b[6]); // c14
+        z[15] = m(a[7], b[8]) + m(a[8], b[7]); // c15
+        z[16] = m(a[8], b[8]); // c16
 
-        z[ 5] = z[10].wrapping_sub(z[ 0]); // c05mc10 - c00
-        z[ 6] = z[11].wrapping_sub(z[ 1]); // c06mc11 - c01
-        z[ 7] = z[12].wrapping_sub(z[ 2]); // c07mc12 - c02
-        z[ 8] = z[ 8].wrapping_sub(z[13]); // c08mc13 - c03
-        z[ 9] = z[14].wrapping_add(z[ 4]); // c14 + c04
+        z[5] = z[10].wrapping_sub(z[0]); // c05mc10 - c00
+        z[6] = z[11].wrapping_sub(z[1]); // c06mc11 - c01
+        z[7] = z[12].wrapping_sub(z[2]); // c07mc12 - c02
+        z[8] = z[8].wrapping_sub(z[13]); // c08mc13 - c03
+        z[9] = z[14].wrapping_add(z[4]); // c14 + c04
         z[10] = z[15].wrapping_add(z[10]); // c15 + c05mc10
         z[11] = z[16].wrapping_add(z[11]); // c16 + c06mc11
 
-        let aa = [
-            a[0]+a[5],
-            a[1]+a[6],
-            a[2]+a[7],
-            a[3]+a[8]
-        ];
+        let aa = [a[0] + a[5], a[1] + a[6], a[2] + a[7], a[3] + a[8]];
 
-        let bb = [
-            b[0]+b[5],
-            b[1]+b[6],
-            b[2]+b[7],
-            b[3]+b[8]
-        ];
+        let bb = [b[0] + b[5], b[1] + b[6], b[2] + b[7], b[3] + b[8]];
 
-        z[ 5] = (m(aa[0],bb[0]))                                                                   .wrapping_add(z[ 5]); // c20 + c05mc10 - c00
-        z[ 6] = (m(aa[0],bb[1]) + m(aa[1],bb[0]))                                                  .wrapping_add(z[ 6]); // c21 + c06mc11 - c01
-        z[ 7] = (m(aa[0],bb[2]) + m(aa[1],bb[1]) + m(aa[2],bb[0]))                                 .wrapping_add(z[ 7]); // c22 + c07mc12 - c02
-        z[ 8] = (m(aa[0],bb[3]) + m(aa[1],bb[2]) + m(aa[2],bb[1]) + m(aa[3],bb[0]))                .wrapping_add(z[ 8]); // c23 + c08mc13 - c03
-        z[ 9] = (m(aa[0], b[4]) + m(aa[1],bb[3]) + m(aa[2],bb[2]) + m(aa[3],bb[1]) + m(a[4],bb[0])).wrapping_sub(z[ 9]); // c24 - c14 - c04
-        z[10] = (                 m(aa[1], b[4]) + m(aa[2],bb[3]) + m(aa[3],bb[2]) + m(a[4],bb[1])).wrapping_sub(z[10]); // c25 - c15 - c05mc10
-        z[11] = (                                  m(aa[2], b[4]) + m(aa[3],bb[3]) + m(a[4],bb[2])).wrapping_sub(z[11]); // c26 - c16 - c06mc11
-        z[12] = (                                                   m(aa[3], b[4]) + m(a[4],bb[3])).wrapping_sub(z[12]); // c27 - c07mc12
+        z[5] = (m(aa[0], bb[0])).wrapping_add(z[5]); // c20 + c05mc10 - c00
+        z[6] = (m(aa[0], bb[1]) + m(aa[1], bb[0])).wrapping_add(z[6]); // c21 + c06mc11 - c01
+        z[7] = (m(aa[0], bb[2]) + m(aa[1], bb[1]) + m(aa[2], bb[0])).wrapping_add(z[7]); // c22 + c07mc12 - c02
+        z[8] = (m(aa[0], bb[3]) + m(aa[1], bb[2]) + m(aa[2], bb[1]) + m(aa[3], bb[0]))
+            .wrapping_add(z[8]); // c23 + c08mc13 - c03
+        z[9] =
+            (m(aa[0], b[4]) + m(aa[1], bb[3]) + m(aa[2], bb[2]) + m(aa[3], bb[1]) + m(a[4], bb[0]))
+                .wrapping_sub(z[9]); // c24 - c14 - c04
+        z[10] = (m(aa[1], b[4]) + m(aa[2], bb[3]) + m(aa[3], bb[2]) + m(a[4], bb[1]))
+            .wrapping_sub(z[10]); // c25 - c15 - c05mc10
+        z[11] = (m(aa[2], b[4]) + m(aa[3], bb[3]) + m(a[4], bb[2])).wrapping_sub(z[11]); // c26 - c16 - c06mc11
+        z[12] = (m(aa[3], b[4]) + m(a[4], bb[3])).wrapping_sub(z[12]); // c27 - c07mc12
 
         z
     }
@@ -264,45 +258,44 @@ impl Scalar29 {
     #[inline(always)]
     fn square_internal(a: &Scalar29) -> [u64; 17] {
         let aa = [
-            a[0]*2,
-            a[1]*2,
-            a[2]*2,
-            a[3]*2,
-            a[4]*2,
-            a[5]*2,
-            a[6]*2,
-            a[7]*2
+            a[0] * 2,
+            a[1] * 2,
+            a[2] * 2,
+            a[3] * 2,
+            a[4] * 2,
+            a[5] * 2,
+            a[6] * 2,
+            a[7] * 2,
         ];
 
         [
-            m( a[0],a[0]),
-            m(aa[0],a[1]),
-            m(aa[0],a[2]) + m( a[1],a[1]),
-            m(aa[0],a[3]) + m(aa[1],a[2]),
-            m(aa[0],a[4]) + m(aa[1],a[3]) + m( a[2],a[2]),
-            m(aa[0],a[5]) + m(aa[1],a[4]) + m(aa[2],a[3]),
-            m(aa[0],a[6]) + m(aa[1],a[5]) + m(aa[2],a[4]) + m( a[3],a[3]),
-            m(aa[0],a[7]) + m(aa[1],a[6]) + m(aa[2],a[5]) + m(aa[3],a[4]),
-            m(aa[0],a[8]) + m(aa[1],a[7]) + m(aa[2],a[6]) + m(aa[3],a[5]) + m( a[4],a[4]),
-                            m(aa[1],a[8]) + m(aa[2],a[7]) + m(aa[3],a[6]) + m(aa[4],a[5]),
-                                            m(aa[2],a[8]) + m(aa[3],a[7]) + m(aa[4],a[6]) + m( a[5],a[5]),
-                                                            m(aa[3],a[8]) + m(aa[4],a[7]) + m(aa[5],a[6]),
-                                                                            m(aa[4],a[8]) + m(aa[5],a[7]) + m( a[6],a[6]),
-                                                                                            m(aa[5],a[8]) + m(aa[6],a[7]),
-                                                                                                            m(aa[6],a[8]) + m( a[7],a[7]),
-                                                                                                                            m(aa[7],a[8]),
-                                                                                                                                            m( a[8],a[8]),
+            m(a[0], a[0]),
+            m(aa[0], a[1]),
+            m(aa[0], a[2]) + m(a[1], a[1]),
+            m(aa[0], a[3]) + m(aa[1], a[2]),
+            m(aa[0], a[4]) + m(aa[1], a[3]) + m(a[2], a[2]),
+            m(aa[0], a[5]) + m(aa[1], a[4]) + m(aa[2], a[3]),
+            m(aa[0], a[6]) + m(aa[1], a[5]) + m(aa[2], a[4]) + m(a[3], a[3]),
+            m(aa[0], a[7]) + m(aa[1], a[6]) + m(aa[2], a[5]) + m(aa[3], a[4]),
+            m(aa[0], a[8]) + m(aa[1], a[7]) + m(aa[2], a[6]) + m(aa[3], a[5]) + m(a[4], a[4]),
+            m(aa[1], a[8]) + m(aa[2], a[7]) + m(aa[3], a[6]) + m(aa[4], a[5]),
+            m(aa[2], a[8]) + m(aa[3], a[7]) + m(aa[4], a[6]) + m(a[5], a[5]),
+            m(aa[3], a[8]) + m(aa[4], a[7]) + m(aa[5], a[6]),
+            m(aa[4], a[8]) + m(aa[5], a[7]) + m(a[6], a[6]),
+            m(aa[5], a[8]) + m(aa[6], a[7]),
+            m(aa[6], a[8]) + m(a[7], a[7]),
+            m(aa[7], a[8]),
+            m(a[8], a[8]),
         ]
     }
 
     /// Compute `limbs/R` (mod l), where R is the Montgomery modulus 2^261
     #[inline(always)]
-    pub (crate) fn montgomery_reduce(limbs: &[u64; 17]) -> Scalar29 {
-
+    pub(crate) fn montgomery_reduce(limbs: &[u64; 17]) -> Scalar29 {
         #[inline(always)]
         fn part1(sum: u64) -> (u64, u32) {
             let p = (sum as u32).wrapping_mul(constants::LFACTOR) & ((1u32 << 29) - 1);
-            ((sum + m(p,constants::L[0])) >> 29, p)
+            ((sum + m(p, constants::L[0])) >> 29, p)
         }
 
         #[inline(always)]
@@ -315,29 +308,38 @@ impl Scalar29 {
         let l = &constants::L;
 
         // the first half computes the Montgomery adjustment factor n, and begins adding n*l to make limbs divisible by R
-        let (carry, n0) = part1(        limbs[ 0]);
-        let (carry, n1) = part1(carry + limbs[ 1] + m(n0,l[1]));
-        let (carry, n2) = part1(carry + limbs[ 2] + m(n0,l[2]) + m(n1,l[1]));
-        let (carry, n3) = part1(carry + limbs[ 3] + m(n0,l[3]) + m(n1,l[2]) + m(n2,l[1]));
-        let (carry, n4) = part1(carry + limbs[ 4] + m(n0,l[4]) + m(n1,l[3]) + m(n2,l[2]) + m(n3,l[1]));
-        let (carry, n5) = part1(carry + limbs[ 5]              + m(n1,l[4]) + m(n2,l[3]) + m(n3,l[2]) + m(n4,l[1]));
-        let (carry, n6) = part1(carry + limbs[ 6]                           + m(n2,l[4]) + m(n3,l[3]) + m(n4,l[2]) + m(n5,l[1]));
-        let (carry, n7) = part1(carry + limbs[ 7]                                        + m(n3,l[4]) + m(n4,l[3]) + m(n5,l[2]) + m(n6,l[1]));
-        let (carry, n8) = part1(carry + limbs[ 8] + m(n0,l[8])                                        + m(n4,l[4]) + m(n5,l[3]) + m(n6,l[2]) + m(n7,l[1]));
+        let (carry, n0) = part1(limbs[0]);
+        let (carry, n1) = part1(carry + limbs[1] + m(n0, l[1]));
+        let (carry, n2) = part1(carry + limbs[2] + m(n0, l[2]) + m(n1, l[1]));
+        let (carry, n3) = part1(carry + limbs[3] + m(n0, l[3]) + m(n1, l[2]) + m(n2, l[1]));
+        let (carry, n4) =
+            part1(carry + limbs[4] + m(n0, l[4]) + m(n1, l[3]) + m(n2, l[2]) + m(n3, l[1]));
+        let (carry, n5) =
+            part1(carry + limbs[5] + m(n1, l[4]) + m(n2, l[3]) + m(n3, l[2]) + m(n4, l[1]));
+        let (carry, n6) =
+            part1(carry + limbs[6] + m(n2, l[4]) + m(n3, l[3]) + m(n4, l[2]) + m(n5, l[1]));
+        let (carry, n7) =
+            part1(carry + limbs[7] + m(n3, l[4]) + m(n4, l[3]) + m(n5, l[2]) + m(n6, l[1]));
+        let (carry, n8) = part1(
+            carry + limbs[8] + m(n0, l[8]) + m(n4, l[4]) + m(n5, l[3]) + m(n6, l[2]) + m(n7, l[1]),
+        );
 
         // limbs is divisible by R now, so we can divide by R by simply storing the upper half as the result
-        let (carry, r0) = part2(carry + limbs[ 9]              + m(n1,l[8])                                        + m(n5,l[4]) + m(n6,l[3]) + m(n7,l[2]) + m(n8,l[1]));
-        let (carry, r1) = part2(carry + limbs[10]                           + m(n2,l[8])                                        + m(n6,l[4]) + m(n7,l[3]) + m(n8,l[2]));
-        let (carry, r2) = part2(carry + limbs[11]                                        + m(n3,l[8])                                        + m(n7,l[4]) + m(n8,l[3]));
-        let (carry, r3) = part2(carry + limbs[12]                                                     + m(n4,l[8])                                        + m(n8,l[4]));
-        let (carry, r4) = part2(carry + limbs[13]                                                                  + m(n5,l[8])                                       );
-        let (carry, r5) = part2(carry + limbs[14]                                                                               + m(n6,l[8])                          );
-        let (carry, r6) = part2(carry + limbs[15]                                                                                            + m(n7,l[8])             );
-        let (carry, r7) = part2(carry + limbs[16]                                                                                                         + m(n8,l[8]));
-        let         r8 = carry as u32;
+        let (carry, r0) = part2(
+            carry + limbs[9] + m(n1, l[8]) + m(n5, l[4]) + m(n6, l[3]) + m(n7, l[2]) + m(n8, l[1]),
+        );
+        let (carry, r1) =
+            part2(carry + limbs[10] + m(n2, l[8]) + m(n6, l[4]) + m(n7, l[3]) + m(n8, l[2]));
+        let (carry, r2) = part2(carry + limbs[11] + m(n3, l[8]) + m(n7, l[4]) + m(n8, l[3]));
+        let (carry, r3) = part2(carry + limbs[12] + m(n4, l[8]) + m(n8, l[4]));
+        let (carry, r4) = part2(carry + limbs[13] + m(n5, l[8]));
+        let (carry, r5) = part2(carry + limbs[14] + m(n6, l[8]));
+        let (carry, r6) = part2(carry + limbs[15] + m(n7, l[8]));
+        let (carry, r7) = part2(carry + limbs[16] + m(n8, l[8]));
+        let r8 = carry as u32;
 
         // result may be >= l, so attempt to subtract l
-        Scalar29::sub(&Scalar29([r0,r1,r2,r3,r4,r5,r6,r7,r8]), l)
+        Scalar29::sub(&Scalar29([r0, r1, r2, r3, r4, r5, r6, r7, r8]), l)
     }
 
     /// Compute `a * b` (mod l).
@@ -393,65 +395,65 @@ mod test {
     /// x = 2^253-1 = 14474011154664524427946373126085988481658748083205070504932198000989141204991
     /// x = 7237005577332262213973186563042994240801631723825162898930247062703686954002 mod l
     /// x = 5147078182513738803124273553712992179887200054963030844803268920753008712037*R mod l in Montgomery form
-    pub static X: Scalar29 = Scalar29(
-        [0x1fffffff, 0x1fffffff, 0x1fffffff, 0x1fffffff,
-         0x1fffffff, 0x1fffffff, 0x1fffffff, 0x1fffffff,
-         0x001fffff]);
+    pub static X: Scalar29 = Scalar29([
+        0x1fffffff, 0x1fffffff, 0x1fffffff, 0x1fffffff, 0x1fffffff, 0x1fffffff, 0x1fffffff,
+        0x1fffffff, 0x001fffff,
+    ]);
 
     /// x^2 = 3078544782642840487852506753550082162405942681916160040940637093560259278169 mod l
-    pub static XX: Scalar29 = Scalar29(
-        [0x00217559, 0x000b3401, 0x103ff43b, 0x1462a62c,
-         0x1d6f9f38, 0x18e7a42f, 0x09a3dcee, 0x008dbe18,
-         0x0006ce65]);
+    pub static XX: Scalar29 = Scalar29([
+        0x00217559, 0x000b3401, 0x103ff43b, 0x1462a62c, 0x1d6f9f38, 0x18e7a42f, 0x09a3dcee,
+        0x008dbe18, 0x0006ce65,
+    ]);
 
     /// x^2 = 2912514428060642753613814151688322857484807845836623976981729207238463947987*R mod l in Montgomery form
-    pub static XX_MONT: Scalar29 = Scalar29(
-        [0x152b4d2e, 0x0571d53b, 0x1da6d964, 0x188663b6,
-         0x1d1b5f92, 0x19d50e3f, 0x12306c29, 0x0c6f26fe,
-         0x00030edb]);
+    pub static XX_MONT: Scalar29 = Scalar29([
+        0x152b4d2e, 0x0571d53b, 0x1da6d964, 0x188663b6, 0x1d1b5f92, 0x19d50e3f, 0x12306c29,
+        0x0c6f26fe, 0x00030edb,
+    ]);
 
     /// y = 6145104759870991071742105800796537629880401874866217824609283457819451087098
-    pub static Y: Scalar29 = Scalar29(
-        [0x1e1458fa, 0x165ba838, 0x1d787b36, 0x0e577f3a,
-         0x1d2baf06, 0x1d689a19, 0x1fff3047, 0x117704ab,
-         0x000d9601]);
+    pub static Y: Scalar29 = Scalar29([
+        0x1e1458fa, 0x165ba838, 0x1d787b36, 0x0e577f3a, 0x1d2baf06, 0x1d689a19, 0x1fff3047,
+        0x117704ab, 0x000d9601,
+    ]);
 
     /// x*y = 36752150652102274958925982391442301741
-    pub static XY: Scalar29 = Scalar29(
-        [0x0ba7632d, 0x017736bb, 0x15c76138, 0x0c69daa1,
-         0x000001ba, 0x00000000, 0x00000000, 0x00000000,
-         0x00000000]);
+    pub static XY: Scalar29 = Scalar29([
+        0x0ba7632d, 0x017736bb, 0x15c76138, 0x0c69daa1, 0x000001ba, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000,
+    ]);
 
     /// x*y = 3783114862749659543382438697751927473898937741870308063443170013240655651591*R mod l in Montgomery form
-    pub static XY_MONT: Scalar29 = Scalar29(
-        [0x077b51e1, 0x1c64e119, 0x02a19ef5, 0x18d2129e,
-         0x00de0430, 0x045a7bc8, 0x04cfc7c9, 0x1c002681,
-         0x000bdc1c]);
+    pub static XY_MONT: Scalar29 = Scalar29([
+        0x077b51e1, 0x1c64e119, 0x02a19ef5, 0x18d2129e, 0x00de0430, 0x045a7bc8, 0x04cfc7c9,
+        0x1c002681, 0x000bdc1c,
+    ]);
 
     /// a = 2351415481556538453565687241199399922945659411799870114962672658845158063753
-    pub static A: Scalar29 = Scalar29(
-        [0x07b3be89, 0x02291b60, 0x14a99f03, 0x07dc3787,
-         0x0a782aae, 0x16262525, 0x0cfdb93f, 0x13f5718d,
-         0x000532da]);
+    pub static A: Scalar29 = Scalar29([
+        0x07b3be89, 0x02291b60, 0x14a99f03, 0x07dc3787, 0x0a782aae, 0x16262525, 0x0cfdb93f,
+        0x13f5718d, 0x000532da,
+    ]);
 
     /// b = 4885590095775723760407499321843594317911456947580037491039278279440296187236
-    pub static B: Scalar29 = Scalar29(
-        [0x15421564, 0x1e69fd72, 0x093d9692, 0x161785be,
-         0x1587d69f, 0x09d9dada, 0x130246c0, 0x0c0a8e72,
-         0x000acd25]);
+    pub static B: Scalar29 = Scalar29([
+        0x15421564, 0x1e69fd72, 0x093d9692, 0x161785be, 0x1587d69f, 0x09d9dada, 0x130246c0,
+        0x0c0a8e72, 0x000acd25,
+    ]);
 
     /// a+b = 0
     /// a-b = 4702830963113076907131374482398799845891318823599740229925345317690316127506
-    pub static AB: Scalar29 = Scalar29(
-        [0x0f677d12, 0x045236c0, 0x09533e06, 0x0fb86f0f,
-         0x14f0555c, 0x0c4c4a4a, 0x19fb727f, 0x07eae31a,
-         0x000a65b5]);
+    pub static AB: Scalar29 = Scalar29([
+        0x0f677d12, 0x045236c0, 0x09533e06, 0x0fb86f0f, 0x14f0555c, 0x0c4c4a4a, 0x19fb727f,
+        0x07eae31a, 0x000a65b5,
+    ]);
 
     // c = (2^512 - 1) % l = 1627715501170711445284395025044413883736156588369414752970002579683115011840
-    pub static C: Scalar29 = Scalar29(
-        [0x049c0f00, 0x00308f1a, 0x0164d1e9, 0x1c374ed1,
-         0x1be65d00, 0x19e90bfa, 0x08f73bb1, 0x036f8613,
-         0x00039941]);
+    pub static C: Scalar29 = Scalar29([
+        0x049c0f00, 0x00308f1a, 0x0164d1e9, 0x1c374ed1, 0x1be65d00, 0x19e90bfa, 0x08f73bb1,
+        0x036f8613, 0x00039941,
+    ]);
 
     #[test]
     fn mul_max() {
diff --git a/src/backend/serial/u64/constants.rs b/src/backend/serial/u64/constants.rs
index 6cbc0b5..22c361a 100644
--- a/src/backend/serial/u64/constants.rs
+++ b/src/backend/serial/u64/constants.rs
@@ -11,11 +11,11 @@
 
 //! This module contains backend-specific constant values, such as the 64-bit limbs of curve constants.
 
-use backend::serial::curve_models::AffineNielsPoint;
+use crate::backend::serial::curve_models::AffineNielsPoint;
 use super::field::FieldElement51;
 use super::scalar::Scalar52;
-use edwards::{EdwardsBasepointTable, EdwardsPoint};
-use window::{LookupTable, NafLookupTable8};
+use crate::edwards::{EdwardsBasepointTable, EdwardsPoint};
+use crate::window::{LookupTable, NafLookupTable8};
 
 /// The value of minus one, equal to `-&FieldElement::one()`
 pub(crate) const MINUS_ONE: FieldElement51 = FieldElement51([
diff --git a/src/backend/serial/u64/scalar.rs b/src/backend/serial/u64/scalar.rs
index cee69da..14f7db5 100644
--- a/src/backend/serial/u64/scalar.rs
+++ b/src/backend/serial/u64/scalar.rs
@@ -16,7 +16,7 @@ use core::ops::{Index, IndexMut};
 
 use zeroize::Zeroize;
 
-use constants;
+use crate::constants;
 
 /// The `Scalar52` struct represents an element in
 /// \\(\mathbb Z / \ell \mathbb Z\\) as 5 \\(52\\)-bit limbs.
diff --git a/src/constants.rs b/src/constants.rs
index 19c46e5..d22a962 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -28,20 +28,20 @@
 
 #![allow(non_snake_case)]
 
-use edwards::CompressedEdwardsY;
-use ristretto::RistrettoPoint;
-use ristretto::CompressedRistretto;
-use montgomery::MontgomeryPoint;
-use scalar::Scalar;
+use crate::edwards::CompressedEdwardsY;
+use crate::montgomery::MontgomeryPoint;
+use crate::ristretto::CompressedRistretto;
+use crate::ristretto::RistrettoPoint;
+use crate::scalar::Scalar;
 
 #[cfg(feature = "fiat_u32_backend")]
-pub use backend::serial::fiat_u32::constants::*;
+pub use crate::backend::serial::fiat_u32::constants::*;
 #[cfg(feature = "fiat_u64_backend")]
-pub use backend::serial::fiat_u64::constants::*;
-#[cfg(feature = "u64_backend")]
-pub use backend::serial::u64::constants::*;
+pub use crate::backend::serial::fiat_u64::constants::*;
 #[cfg(feature = "u32_backend")]
-pub use backend::serial::u32::constants::*;
+pub use crate::backend::serial::u32::constants::*;
+#[cfg(feature = "u64_backend")]
+pub use crate::backend::serial::u64::constants::*;
 
 /// The Ed25519 basepoint, in `CompressedEdwardsY` format.
 ///
@@ -49,25 +49,22 @@ pub use backend::serial::u32::constants::*;
 /// which is the \\(y\\)-coordinate of the Ed25519 basepoint.
 ///
 /// The sign bit is 0 since the basepoint has \\(x\\) chosen to be positive.
-pub const ED25519_BASEPOINT_COMPRESSED: CompressedEdwardsY =
-    CompressedEdwardsY([0x58, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
-                        0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
-                        0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
-                        0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66]);
+pub const ED25519_BASEPOINT_COMPRESSED: CompressedEdwardsY = CompressedEdwardsY([
+    0x58, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
+    0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
+]);
 
 /// The X25519 basepoint, in `MontgomeryPoint` format.
-pub const X25519_BASEPOINT: MontgomeryPoint =
-    MontgomeryPoint([0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+pub const X25519_BASEPOINT: MontgomeryPoint = MontgomeryPoint([
+    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+]);
 
 /// The Ristretto basepoint, in `CompressedRistretto` format.
-pub const RISTRETTO_BASEPOINT_COMPRESSED: CompressedRistretto =
-    CompressedRistretto([0xe2, 0xf2, 0xae, 0x0a, 0x6a, 0xbc, 0x4e, 0x71,
-                         0xa8, 0x84, 0xa9, 0x61, 0xc5, 0x00, 0x51, 0x5f,
-                         0x58, 0xe3, 0x0b, 0x6a, 0xa5, 0x82, 0xdd, 0x8d,
-                         0xb6, 0xa6, 0x59, 0x45, 0xe0, 0x8d, 0x2d, 0x76]);
+pub const RISTRETTO_BASEPOINT_COMPRESSED: CompressedRistretto = CompressedRistretto([
+    0xe2, 0xf2, 0xae, 0x0a, 0x6a, 0xbc, 0x4e, 0x71, 0xa8, 0x84, 0xa9, 0x61, 0xc5, 0x00, 0x51, 0x5f,
+    0x58, 0xe3, 0x0b, 0x6a, 0xa5, 0x82, 0xdd, 0x8d, 0xb6, 0xa6, 0x59, 0x45, 0xe0, 0x8d, 0x2d, 0x76,
+]);
 
 /// The Ristretto basepoint, as a `RistrettoPoint`.
 ///
@@ -79,25 +76,24 @@ pub const RISTRETTO_BASEPOINT_POINT: RistrettoPoint = RistrettoPoint(ED25519_BAS
 /// $$
 /// \ell = 2^\{252\} + 27742317777372353535851937790883648493.
 /// $$
-pub const BASEPOINT_ORDER: Scalar = Scalar{
+pub const BASEPOINT_ORDER: Scalar = Scalar {
     bytes: [
-        0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
-        0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+        0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde,
+        0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x10,
     ],
 };
 
-use ristretto::RistrettoBasepointTable;
+use crate::ristretto::RistrettoBasepointTable;
 /// The Ristretto basepoint, as a `RistrettoBasepointTable` for scalar multiplication.
-pub const RISTRETTO_BASEPOINT_TABLE: RistrettoBasepointTable
-    = RistrettoBasepointTable(ED25519_BASEPOINT_TABLE);
+pub const RISTRETTO_BASEPOINT_TABLE: RistrettoBasepointTable =
+    RistrettoBasepointTable(ED25519_BASEPOINT_TABLE);
 
 #[cfg(test)]
 mod test {
-    use field::FieldElement;
-    use traits::{IsIdentity, ValidityCheck};
-    use constants;
+    use crate::constants;
+    use crate::field::FieldElement;
+    use crate::traits::{IsIdentity, ValidityCheck};
 
     #[test]
     fn test_eight_torsion() {
@@ -131,7 +127,7 @@ mod test {
     fn test_sqrt_minus_one() {
         let minus_one = FieldElement::minus_one();
         let sqrt_m1_sq = &constants::SQRT_M1 * &constants::SQRT_M1;
-        assert_eq!(minus_one,  sqrt_m1_sq);
+        assert_eq!(minus_one, sqrt_m1_sq);
         assert_eq!(constants::SQRT_M1.is_negative().unwrap_u8(), 0);
     }
 
@@ -140,7 +136,7 @@ mod test {
         let minus_one = FieldElement::minus_one();
         let (was_nonzero_square, invsqrt_m1) = minus_one.invsqrt();
         assert_eq!(was_nonzero_square.unwrap_u8(), 1u8);
-        let sign_test_sqrt  = &invsqrt_m1 * &constants::SQRT_M1;
+        let sign_test_sqrt = &invsqrt_m1 * &constants::SQRT_M1;
         assert_eq!(sign_test_sqrt, minus_one);
     }
 
@@ -148,9 +144,9 @@ mod test {
     #[test]
     #[cfg(feature = "u32_backend")]
     fn test_d_vs_ratio() {
-        use backend::serial::u32::field::FieldElement2625;
-        let a = -&FieldElement2625([121665,0,0,0,0,0,0,0,0,0]);
-        let b =   FieldElement2625([121666,0,0,0,0,0,0,0,0,0]);
+        use crate::backend::serial::u32::field::FieldElement2625;
+        let a = -&FieldElement2625([121665, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+        let b = FieldElement2625([121666, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
         let d = &a * &b.invert();
         let d2 = &d + &d;
         assert_eq!(d, constants::EDWARDS_D);
@@ -161,9 +157,9 @@ mod test {
     #[test]
     #[cfg(feature = "u64_backend")]
     fn test_d_vs_ratio() {
-        use backend::serial::u64::field::FieldElement51;
-        let a = -&FieldElement51([121665,0,0,0,0]);
-        let b =   FieldElement51([121666,0,0,0,0]);
+        use crate::backend::serial::u64::field::FieldElement51;
+        let a = -&FieldElement51([121665, 0, 0, 0, 0]);
+        let b = FieldElement51([121666, 0, 0, 0, 0]);
         let d = &a * &b.invert();
         let d2 = &d + &d;
         assert_eq!(d, constants::EDWARDS_D);
@@ -177,5 +173,4 @@ mod test {
         let should_be_ad_minus_one = constants::SQRT_AD_MINUS_ONE.square();
         assert_eq!(should_be_ad_minus_one, ad_minus_one);
     }
-
 }
diff --git a/src/edwards.rs b/src/edwards.rs
index 0a591a1..5dd18e3 100644
--- a/src/edwards.rs
+++ b/src/edwards.rs
@@ -109,41 +109,41 @@ use subtle::ConstantTimeEq;
 
 use zeroize::Zeroize;
 
-use constants;
+use crate::constants;
 
-use field::FieldElement;
-use scalar::Scalar;
+use crate::field::FieldElement;
+use crate::scalar::Scalar;
 
-use montgomery::MontgomeryPoint;
+use crate::montgomery::MontgomeryPoint;
 
-use backend::serial::curve_models::AffineNielsPoint;
-use backend::serial::curve_models::CompletedPoint;
-use backend::serial::curve_models::ProjectiveNielsPoint;
-use backend::serial::curve_models::ProjectivePoint;
+use crate::backend::serial::curve_models::AffineNielsPoint;
+use crate::backend::serial::curve_models::CompletedPoint;
+use crate::backend::serial::curve_models::ProjectiveNielsPoint;
+use crate::backend::serial::curve_models::ProjectivePoint;
 
-use window::LookupTableRadix16;
-use window::LookupTableRadix32;
-use window::LookupTableRadix64;
-use window::LookupTableRadix128;
-use window::LookupTableRadix256;
+use crate::window::LookupTableRadix16;
+use crate::window::LookupTableRadix32;
+use crate::window::LookupTableRadix64;
+use crate::window::LookupTableRadix128;
+use crate::window::LookupTableRadix256;
 
 #[allow(unused_imports)]
-use prelude::*;
+use crate::prelude::*;
 
-use traits::BasepointTable;
-use traits::ValidityCheck;
-use traits::{Identity, IsIdentity};
+use crate::traits::BasepointTable;
+use crate::traits::ValidityCheck;
+use crate::traits::{Identity, IsIdentity};
 
 #[cfg(any(feature = "alloc", feature = "std"))]
-use traits::MultiscalarMul;
+use crate::traits::MultiscalarMul;
 #[cfg(any(feature = "alloc", feature = "std"))]
-use traits::{VartimeMultiscalarMul, VartimePrecomputedMultiscalarMul};
+use crate::traits::{VartimeMultiscalarMul, VartimePrecomputedMultiscalarMul};
 
 #[cfg(not(all(
     feature = "simd_backend",
     any(target_feature = "avx2", target_feature = "avx512ifma")
 )))]
-use backend::serial::scalar_mul;
+use crate::backend::serial::scalar_mul;
 #[cfg(all(
     feature = "simd_backend",
     any(target_feature = "avx2", target_feature = "avx512ifma")
@@ -1087,10 +1087,10 @@ impl Debug for EdwardsPoint {
 
 #[cfg(test)]
 mod test {
-    use field::FieldElement;
-    use scalar::Scalar;
+    use crate::field::FieldElement;
+    use crate::scalar::Scalar;
     use subtle::ConditionallySelectable;
-    use constants;
+    use crate::constants;
     use super::*;
 
     /// X coordinate of the basepoint.
@@ -1530,7 +1530,7 @@ mod test {
     fn vartime_precomputed_vs_nonprecomputed_multiscalar() {
         let mut rng = rand::thread_rng();
 
-        let B = &::constants::ED25519_BASEPOINT_TABLE;
+        let B = &crate::constants::ED25519_BASEPOINT_TABLE;
 
         let static_scalars = (0..128)
             .map(|_| Scalar::random(&mut rng))
@@ -1557,7 +1557,7 @@ mod test {
             &dynamic_points,
         );
 
-        use traits::VartimeMultiscalarMul;
+        use crate::traits::VartimeMultiscalarMul;
         let Q = EdwardsPoint::vartime_multiscalar_mul(
             static_scalars.iter().chain(dynamic_scalars.iter()),
             static_points.iter().chain(dynamic_points.iter()),
diff --git a/src/field.rs b/src/field.rs
index 109cff2..b312b25 100644
--- a/src/field.rs
+++ b/src/field.rs
@@ -30,8 +30,8 @@ use subtle::ConditionallyNegatable;
 use subtle::Choice;
 use subtle::ConstantTimeEq;
 
-use constants;
-use backend;
+use crate::constants;
+use crate::backend;
 
 #[cfg(feature = "fiat_u32_backend")]
 pub use backend::serial::fiat_u32::field::*;
@@ -49,7 +49,7 @@ pub type FieldElement = backend::serial::fiat_u32::field::FieldElement2625;
 pub type FieldElement = backend::serial::fiat_u64::field::FieldElement51;
 
 #[cfg(feature = "u64_backend")]
-pub use backend::serial::u64::field::*;
+pub use crate::backend::serial::u64::field::*;
 /// A `FieldElement` represents an element of the field
 /// \\( \mathbb Z / (2\^{255} - 19)\\).
 ///
@@ -293,7 +293,7 @@ impl FieldElement {
 
 #[cfg(test)]
 mod test {
-    use field::*;
+    use crate::field::*;
     use subtle::ConditionallyNegatable;
 
     /// Random element a of GF(2^255-19), from Sage
diff --git a/src/lib.rs b/src/lib.rs
index ae5f954..0e18d5f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,10 +13,8 @@
 #![cfg_attr(feature = "nightly", feature(test))]
 #![cfg_attr(feature = "nightly", feature(doc_cfg))]
 #![cfg_attr(feature = "simd_backend", feature(stdsimd))]
-
 // Refuse to compile if documentation is missing.
 #![deny(missing_docs)]
-
 #![doc(html_logo_url = "https://doc.dalek.rs/assets/dalek-logo-clear.png")]
 #![doc(html_root_url = "https://docs.rs/curve25519-dalek/4.0.0-pre.2")]
 
@@ -258,24 +256,7 @@ extern crate alloc;
 #[macro_use]
 extern crate std;
 
-#[cfg(all(feature = "nightly", feature = "packed_simd"))]
-extern crate packed_simd;
-
-extern crate byteorder;
-pub extern crate digest;
-extern crate rand_core;
-extern crate zeroize;
-
-#[cfg(any(feature = "fiat_u64_backend", feature = "fiat_u32_backend"))]
-extern crate fiat_crypto;
-
-// Used for traits related to constant-time code.
-extern crate subtle;
-
-#[cfg(all(test, feature = "serde"))]
-extern crate bincode;
-#[cfg(feature = "serde")]
-extern crate serde;
+pub use digest;
 
 // Internal macros. Must come first!
 #[macro_use]
diff --git a/src/montgomery.rs b/src/montgomery.rs
index 88afbd9..e1df1c9 100644
--- a/src/montgomery.rs
+++ b/src/montgomery.rs
@@ -51,12 +51,12 @@
 
 use core::ops::{Mul, MulAssign};
 
-use constants::{APLUS2_OVER_FOUR, MONTGOMERY_A, MONTGOMERY_A_NEG};
-use edwards::{CompressedEdwardsY, EdwardsPoint};
-use field::FieldElement;
-use scalar::Scalar;
+use crate::constants::{APLUS2_OVER_FOUR, MONTGOMERY_A, MONTGOMERY_A_NEG};
+use crate::edwards::{CompressedEdwardsY, EdwardsPoint};
+use crate::field::FieldElement;
+use crate::scalar::Scalar;
 
-use traits::Identity;
+use crate::traits::Identity;
 
 use subtle::Choice;
 use subtle::ConstantTimeEq;
@@ -353,8 +353,7 @@ impl<'a, 'b> Mul<&'b MontgomeryPoint> for &'a Scalar {
 #[cfg(test)]
 mod test {
     use super::*;
-    use constants;
-    use core::convert::TryInto;
+    use crate::constants;
 
     use rand_core::OsRng;
 
diff --git a/src/ristretto.rs b/src/ristretto.rs
index eaec4a9..94c537c 100644
--- a/src/ristretto.rs
+++ b/src/ristretto.rs
@@ -170,8 +170,8 @@ use rand_core::{CryptoRng, RngCore};
 use digest::generic_array::typenum::U64;
 use digest::Digest;
 
-use constants;
-use field::FieldElement;
+use crate::constants;
+use crate::field::FieldElement;
 
 use subtle::Choice;
 use subtle::ConditionallySelectable;
@@ -180,24 +180,24 @@ use subtle::ConstantTimeEq;
 
 use zeroize::Zeroize;
 
-use edwards::EdwardsBasepointTable;
-use edwards::EdwardsPoint;
+use crate::edwards::EdwardsBasepointTable;
+use crate::edwards::EdwardsPoint;
 
 #[allow(unused_imports)]
-use prelude::*;
+use crate::prelude::*;
 
-use scalar::Scalar;
+use crate::scalar::Scalar;
 
-use traits::BasepointTable;
-use traits::Identity;
+use crate::traits::BasepointTable;
+use crate::traits::Identity;
 #[cfg(any(feature = "alloc", feature = "std"))]
-use traits::{MultiscalarMul, VartimeMultiscalarMul, VartimePrecomputedMultiscalarMul};
+use crate::traits::{MultiscalarMul, VartimeMultiscalarMul, VartimePrecomputedMultiscalarMul};
 
 #[cfg(not(all(
     feature = "simd_backend",
     any(target_feature = "avx2", target_feature = "avx512ifma")
 )))]
-use backend::serial::scalar_mul;
+use crate::backend::serial::scalar_mul;
 #[cfg(all(
     feature = "simd_backend",
     any(target_feature = "avx2", target_feature = "avx512ifma")
@@ -487,9 +487,7 @@ impl RistrettoPoint {
     /// in a batch.
     ///
     /// ```
-    /// # extern crate curve25519_dalek;
     /// # use curve25519_dalek::ristretto::RistrettoPoint;
-    /// extern crate rand_core;
     /// use rand_core::OsRng;
     ///
     /// # // Need fn main() here in comment so the doctest compiles
@@ -625,7 +623,7 @@ impl RistrettoPoint {
         let N_t = &(&(&c * &(&r - &one)) * &d_minus_one_sq) - &D;
         let s_sq = s.square();
 
-        use backend::serial::curve_models::CompletedPoint;
+        use crate::backend::serial::curve_models::CompletedPoint;
 
         // The conversion from W_i is exactly the conversion from P1xP1.
         RistrettoPoint(CompletedPoint{
@@ -676,9 +674,7 @@ impl RistrettoPoint {
     /// # Example
     ///
     /// ```
-    /// # extern crate curve25519_dalek;
     /// # use curve25519_dalek::ristretto::RistrettoPoint;
-    /// extern crate sha2;
     /// use sha2::Sha512;
     ///
     /// # // Need fn main() here in comment so the doctest compiles
@@ -1033,9 +1029,6 @@ impl ConditionallySelectable for RistrettoPoint {
     /// # Example
     ///
     /// ```
-    /// # extern crate subtle;
-    /// # extern crate curve25519_dalek;
-    /// #
     /// use subtle::ConditionallySelectable;
     /// use subtle::Choice;
     /// #
@@ -1106,10 +1099,10 @@ impl Zeroize for RistrettoPoint {
 mod test {
     use rand_core::OsRng;
 
-    use scalar::Scalar;
-    use constants;
-    use edwards::CompressedEdwardsY;
-    use traits::{Identity};
+    use crate::scalar::Scalar;
+    use crate::constants;
+    use crate::edwards::CompressedEdwardsY;
+    use crate::traits::{Identity};
     use super::*;
 
     #[test]
@@ -1344,7 +1337,7 @@ mod test {
     fn vartime_precomputed_vs_nonprecomputed_multiscalar() {
         let mut rng = rand::thread_rng();
 
-        let B = &::constants::RISTRETTO_BASEPOINT_TABLE;
+        let B = &crate::constants::RISTRETTO_BASEPOINT_TABLE;
 
         let static_scalars = (0..128)
             .map(|_| Scalar::random(&mut rng))
@@ -1371,7 +1364,7 @@ mod test {
             &dynamic_points,
         );
 
-        use traits::VartimeMultiscalarMul;
+        use crate::traits::VartimeMultiscalarMul;
         let Q = RistrettoPoint::vartime_multiscalar_mul(
             static_scalars.iter().chain(dynamic_scalars.iter()),
             static_points.iter().chain(dynamic_points.iter()),
diff --git a/src/scalar.rs b/src/scalar.rs
index cb81ee8..3adf046 100644
--- a/src/scalar.rs
+++ b/src/scalar.rs
@@ -91,9 +91,6 @@
 //! which allows an IUF API.
 //!
 //! ```
-//! # extern crate curve25519_dalek;
-//! # extern crate sha2;
-//! #
 //! # fn main() {
 //! use sha2::{Digest, Sha512};
 //! use curve25519_dalek::scalar::Scalar;
@@ -150,7 +147,7 @@ use core::ops::{Mul, MulAssign};
 use core::ops::{Sub, SubAssign};
 
 #[allow(unused_imports)]
-use prelude::*;
+use crate::prelude::*;
 
 use rand_core::{CryptoRng, RngCore};
 
@@ -163,8 +160,8 @@ use subtle::ConstantTimeEq;
 
 use zeroize::Zeroize;
 
-use backend;
-use constants;
+use crate::backend;
+use crate::constants;
 
 /// An `UnpackedScalar` represents an element of the field GF(l), optimized for speed.
 ///
@@ -554,9 +551,6 @@ impl Scalar {
     /// # Example
     ///
     /// ```
-    /// extern crate rand_core;
-    /// # extern crate curve25519_dalek;
-    /// #
     /// # fn main() {
     /// use curve25519_dalek::scalar::Scalar;
     ///
@@ -581,10 +575,7 @@ impl Scalar {
     /// # Example
     ///
     /// ```
-    /// # extern crate curve25519_dalek;
     /// # use curve25519_dalek::scalar::Scalar;
-    /// extern crate sha2;
-    ///
     /// use sha2::Sha512;
     ///
     /// # // Need fn main() here in comment so the doctest compiles
@@ -611,10 +602,7 @@ impl Scalar {
     /// # Example
     ///
     /// ```
-    /// # extern crate curve25519_dalek;
     /// # use curve25519_dalek::scalar::Scalar;
-    /// extern crate sha2;
-    ///
     /// use curve25519_dalek::digest::Update;
     ///
     /// use sha2::Digest;
@@ -750,7 +738,6 @@ impl Scalar {
     /// # Example
     ///
     /// ```
-    /// # extern crate curve25519_dalek;
     /// # use curve25519_dalek::scalar::Scalar;
     /// # fn main() {
     /// let mut scalars = [
@@ -1115,8 +1102,6 @@ impl Scalar {
     /// This is intended for uses like input validation, where variable-time code is acceptable.
     ///
     /// ```
-    /// # extern crate curve25519_dalek;
-    /// # extern crate subtle;
     /// # use curve25519_dalek::scalar::Scalar;
     /// # use subtle::ConditionallySelectable;
     /// # fn main() {
@@ -1204,7 +1189,7 @@ impl UnpackedScalar {
 #[cfg(test)]
 mod test {
     use super::*;
-    use constants;
+    use crate::constants;
 
     /// x = 2238329342913194256032495932344128051776374960164957527413114840482143558222
     pub static X: Scalar = Scalar{
diff --git a/src/traits.rs b/src/traits.rs
index d127b3e..4e67840 100644
--- a/src/traits.rs
+++ b/src/traits.rs
@@ -17,7 +17,7 @@ use core::borrow::Borrow;
 
 use subtle;
 
-use scalar::Scalar;
+use crate::scalar::Scalar;
 
 // ------------------------------------------------------------------------
 // Public Traits
diff --git a/src/window.rs b/src/window.rs
index 2cf1fbe..253126f 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -20,11 +20,11 @@ use subtle::ConditionallySelectable;
 use subtle::ConstantTimeEq;
 use subtle::Choice;
 
-use traits::Identity;
+use crate::traits::Identity;
 
-use edwards::EdwardsPoint;
-use backend::serial::curve_models::ProjectiveNielsPoint;
-use backend::serial::curve_models::AffineNielsPoint;
+use crate::edwards::EdwardsPoint;
+use crate::backend::serial::curve_models::ProjectiveNielsPoint;
+use crate::backend::serial::curve_models::AffineNielsPoint;
 
 use zeroize::Zeroize;