diff --git a/crypto-glue/src/aes_fruity.rs b/crypto-glue/src/aes_fruity.rs
index cb43109..f0da0ce 100644
--- a/crypto-glue/src/aes_fruity.rs
+++ b/crypto-glue/src/aes_fruity.rs
@@ -59,8 +59,18 @@ extern "C" {
     fn CCCryptorRelease(cryptor_ref: *mut c_void) -> i32;
     fn CCCryptorGCMSetIV(cryptor_ref: *mut c_void, iv: *const c_void, iv_len: usize) -> i32;
     fn CCCryptorGCMAddAAD(cryptor_ref: *mut c_void, aad: *const c_void, len: usize) -> i32;
-    fn CCCryptorGCMEncrypt(cryptor_ref: *mut c_void, data_in: *const c_void, data_in_len: usize, data_out: *mut c_void) -> i32;
-    fn CCCryptorGCMDecrypt(cryptor_ref: *mut c_void, data_in: *const c_void, data_in_len: usize, data_out: *mut c_void) -> i32;
+    fn CCCryptorGCMEncrypt(
+        cryptor_ref: *mut c_void,
+        data_in: *const c_void,
+        data_in_len: usize,
+        data_out: *mut c_void,
+    ) -> i32;
+    fn CCCryptorGCMDecrypt(
+        cryptor_ref: *mut c_void,
+        data_in: *const c_void,
+        data_in_len: usize,
+        data_out: *mut c_void,
+    ) -> i32;
     fn CCCryptorGCMFinal(cryptor_ref: *mut c_void, tag: *mut c_void, tag_len: *mut usize) -> i32;
     fn CCCryptorGCMReset(cryptor_ref: *mut c_void) -> i32;
 }
@@ -141,9 +151,15 @@ impl<const ENCRYPT: bool> AesGcm<ENCRYPT> {
     pub fn crypt_in_place(&mut self, data: &mut [u8]) {
         unsafe {
             if ENCRYPT {
-                assert_eq!(CCCryptorGCMEncrypt(self.0, data.as_ptr().cast(), data.len(), data.as_mut_ptr().cast()), 0);
+                assert_eq!(
+                    CCCryptorGCMEncrypt(self.0, data.as_ptr().cast(), data.len(), data.as_mut_ptr().cast()),
+                    0
+                );
             } else {
-                assert_eq!(CCCryptorGCMDecrypt(self.0, data.as_ptr().cast(), data.len(), data.as_mut_ptr().cast()), 0);
+                assert_eq!(
+                    CCCryptorGCMDecrypt(self.0, data.as_ptr().cast(), data.len(), data.as_mut_ptr().cast()),
+                    0
+                );
             }
         }
     }
diff --git a/crypto-glue/src/aes_gmac_siv_fruity.rs b/crypto-glue/src/aes_gmac_siv_fruity.rs
index dc2864d..40d446b 100644
--- a/crypto-glue/src/aes_gmac_siv_fruity.rs
+++ b/crypto-glue/src/aes_gmac_siv_fruity.rs
@@ -456,7 +456,11 @@ impl AesGmacSiv {
                 ciphertext_to_plaintext.len(),
                 &mut data_out_written,
             );
-            CCCryptorGCMAddAAD(self.gmac, ciphertext_to_plaintext.as_ptr().cast(), ciphertext_to_plaintext.len());
+            CCCryptorGCMAddAAD(
+                self.gmac,
+                ciphertext_to_plaintext.as_ptr().cast(),
+                ciphertext_to_plaintext.len(),
+            );
         }
     }
 
diff --git a/crypto-glue/src/aes_gmac_siv_openssl.rs b/crypto-glue/src/aes_gmac_siv_openssl.rs
index dd2d97f..c898a0b 100644
--- a/crypto-glue/src/aes_gmac_siv_openssl.rs
+++ b/crypto-glue/src/aes_gmac_siv_openssl.rs
@@ -144,7 +144,9 @@ impl AesGmacSiv {
         self.tmp[12] &= 0x7f;
 
         unsafe {
-            self.ctr.cipher_init::<true>(ptr::null_mut(), ptr::null_mut(), self.tmp.as_ptr()).unwrap();
+            self.ctr
+                .cipher_init::<true>(ptr::null_mut(), ptr::null_mut(), self.tmp.as_ptr())
+                .unwrap();
         }
     }
 
@@ -196,7 +198,9 @@ impl AesGmacSiv {
         tag_tmp[8..12].fill(0);
 
         unsafe {
-            self.gmac.cipher_init::<true>(ptr::null_mut(), ptr::null_mut(), tag_tmp.as_ptr()).unwrap();
+            self.gmac
+                .cipher_init::<true>(ptr::null_mut(), ptr::null_mut(), tag_tmp.as_ptr())
+                .unwrap();
         }
     }
 
diff --git a/crypto-glue/src/aes_openssl.rs b/crypto-glue/src/aes_openssl.rs
index 054c152..8efd864 100644
--- a/crypto-glue/src/aes_openssl.rs
+++ b/crypto-glue/src/aes_openssl.rs
@@ -41,7 +41,9 @@ impl<const ENCRYPT: bool> AesGcm<ENCRYPT> {
     /// `iv` must be exactly 12 bytes in length, because that is what Aes supports.
     fn reset_init_gcm(&mut self, iv: &[u8]) {
         unsafe {
-            self.0.cipher_init::<ENCRYPT>(ptr::null(), ptr::null(), iv.as_ptr()).unwrap();
+            self.0
+                .cipher_init::<ENCRYPT>(ptr::null(), ptr::null(), iv.as_ptr())
+                .unwrap();
         }
     }
 
@@ -145,7 +147,8 @@ impl<const ENCRYPT: bool> Aes<ENCRYPT> {
     fn reset(&self, key: &[u8; aes::AES_256_KEY_SIZE]) {
         let ctx = self.0.lock().unwrap();
         unsafe {
-            ctx.cipher_init::<ENCRYPT>(ptr::null(), key.as_ptr(), ptr::null()).unwrap();
+            ctx.cipher_init::<ENCRYPT>(ptr::null(), key.as_ptr(), ptr::null())
+                .unwrap();
         }
     }
 }
diff --git a/crypto-glue/src/aes_tests.rs b/crypto-glue/src/aes_tests.rs
index 7e5bc32..2f49e39 100644
--- a/crypto-glue/src/aes_tests.rs
+++ b/crypto-glue/src/aes_tests.rs
@@ -163,10 +163,12 @@ mod test {
     #[test]
     fn aes_gmac_siv_encrypt_decrypt() {
         let aes_key_0: [u8; 32] = [
-            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+            30, 31, 32,
         ];
         let aes_key_1: [u8; 32] = [
-            2, 3, 4, 5, 6, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+            2, 3, 4, 5, 6, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+            30, 31, 32,
         ];
         let iv: [u8; 8] = [0, 1, 2, 3, 4, 5, 6, 7];
 
@@ -186,7 +188,8 @@ mod test {
             let tag = *c.encrypt_second_pass_finish();
             let sha = crate::hash::SHA384::hash(&buf).to_vec();
             let sha = to_hex(sha.as_slice());
-            if sha != "4dc97c10abb6112a3907e5eb588ea5123719442b715da994d9756b003677719824326973960268823d924f66491a16e6" {
+            if sha != "4dc97c10abb6112a3907e5eb588ea5123719442b715da994d9756b003677719824326973960268823d924f66491a16e6"
+            {
                 panic!("encrypt result hash check failed! {}", sha);
             }
             //println!("Encrypt OK, tag: {}, hash: {}", to_hex(&tag), sha);
diff --git a/crypto-glue/src/cipher_ctx.rs b/crypto-glue/src/cipher_ctx.rs
index c2c5db3..3f6586f 100644
--- a/crypto-glue/src/cipher_ctx.rs
+++ b/crypto-glue/src/cipher_ctx.rs
@@ -15,12 +15,34 @@ extern "C" {
     fn EVP_CIPHER_CTX_free(ctx: *mut ffi::EVP_CIPHER_CTX);
     fn EVP_CIPHER_CTX_new() -> *mut ffi::EVP_CIPHER_CTX;
 
-    fn EVP_EncryptInit_ex(ctx: *mut ffi::EVP_CIPHER_CTX, cipher: *const ffi::EVP_CIPHER, engine: *mut c_void, key: *const u8, iv: *const u8)
-        -> c_int;
-    fn EVP_DecryptInit_ex(ctx: *mut ffi::EVP_CIPHER_CTX, cipher: *const ffi::EVP_CIPHER, engine: *mut c_void, key: *const u8, iv: *const u8)
-        -> c_int;
-    fn EVP_EncryptUpdate(ctx: *mut ffi::EVP_CIPHER_CTX, out: *mut u8, outl: *mut c_int, in_: *const u8, inl: c_int) -> c_int;
-    fn EVP_DecryptUpdate(ctx: *mut ffi::EVP_CIPHER_CTX, out: *mut u8, outl: *mut c_int, in_: *const u8, inl: c_int) -> c_int;
+    fn EVP_EncryptInit_ex(
+        ctx: *mut ffi::EVP_CIPHER_CTX,
+        cipher: *const ffi::EVP_CIPHER,
+        engine: *mut c_void,
+        key: *const u8,
+        iv: *const u8,
+    ) -> c_int;
+    fn EVP_DecryptInit_ex(
+        ctx: *mut ffi::EVP_CIPHER_CTX,
+        cipher: *const ffi::EVP_CIPHER,
+        engine: *mut c_void,
+        key: *const u8,
+        iv: *const u8,
+    ) -> c_int;
+    fn EVP_EncryptUpdate(
+        ctx: *mut ffi::EVP_CIPHER_CTX,
+        out: *mut u8,
+        outl: *mut c_int,
+        in_: *const u8,
+        inl: c_int,
+    ) -> c_int;
+    fn EVP_DecryptUpdate(
+        ctx: *mut ffi::EVP_CIPHER_CTX,
+        out: *mut u8,
+        outl: *mut c_int,
+        in_: *const u8,
+        inl: c_int,
+    ) -> c_int;
     fn EVP_EncryptFinal_ex(ctx: *mut ffi::EVP_CIPHER_CTX, out: *mut u8, outl: *mut c_int) -> c_int;
     fn EVP_DecryptFinal_ex(ctx: *mut ffi::EVP_CIPHER_CTX, out: *mut u8, outl: *mut c_int) -> c_int;
     fn EVP_CIPHER_CTX_ctrl(ctx: *mut ffi::EVP_CIPHER_CTX, type_: c_int, arg: c_int, ptr: *mut c_void) -> c_int;
@@ -48,7 +70,12 @@ impl CipherCtx {
 impl CipherCtx {
     /// Initializes the context for encryption or decryption.
     /// All pointer fields can be null, in which case the corresponding field in the context is not updated.
-    pub unsafe fn cipher_init<const ENCRYPT: bool>(&self, t: *const ffi::EVP_CIPHER, key: *const u8, iv: *const u8) -> Result<(), ErrorStack> {
+    pub unsafe fn cipher_init<const ENCRYPT: bool>(
+        &self,
+        t: *const ffi::EVP_CIPHER,
+        key: *const u8,
+        iv: *const u8,
+    ) -> Result<(), ErrorStack> {
         let evp_f = if ENCRYPT {
             EVP_EncryptInit_ex
         } else {
@@ -84,7 +111,13 @@ impl CipherCtx {
 
         let mut outlen = 0;
 
-        cvt(evp_f(self.0.as_ptr(), output, &mut outlen, input.as_ptr(), input.len() as c_int))?;
+        cvt(evp_f(
+            self.0.as_ptr(),
+            output,
+            &mut outlen,
+            input.as_ptr(),
+            input.len() as c_int,
+        ))?;
 
         Ok(())
     }
@@ -157,7 +190,8 @@ mod test {
         let key = [1u8; 16];
         let ctx = CipherCtx::new().unwrap();
         unsafe {
-            ctx.cipher_init::<true>(ffi::EVP_aes_128_ecb(), key.as_ptr(), ptr::null()).unwrap();
+            ctx.cipher_init::<true>(ffi::EVP_aes_128_ecb(), key.as_ptr(), ptr::null())
+                .unwrap();
             ffi::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
             assert_eq!(ffi::EVP_CIPHER_CTX_get_block_size(ctx.as_ptr()) as usize, 16);
 
@@ -166,7 +200,8 @@ mod test {
             let p = val.as_mut_ptr();
 
             ctx.update::<true>(&val, p).unwrap();
-            ctx.cipher_init::<false>(ptr::null(), key.as_ptr(), ptr::null()).unwrap();
+            ctx.cipher_init::<false>(ptr::null(), key.as_ptr(), ptr::null())
+                .unwrap();
             ctx.update::<false>(&val, p).unwrap();
 
             assert_eq!(val, origin);
diff --git a/crypto-glue/src/error.rs b/crypto-glue/src/error.rs
index abed85b..e97b09a 100644
--- a/crypto-glue/src/error.rs
+++ b/crypto-glue/src/error.rs
@@ -148,7 +148,11 @@ impl Error {
             let data = match self.data {
                 Some(Cow::Borrowed(data)) => Some((data.as_ptr() as *mut c_char, 0)),
                 Some(Cow::Owned(ref data)) => {
-                    let ptr = ffi::CRYPTO_malloc((data.len() + 1) as _, concat!(file!(), "\0").as_ptr() as _, line!() as _) as *mut c_char;
+                    let ptr = ffi::CRYPTO_malloc(
+                        (data.len() + 1) as _,
+                        concat!(file!(), "\0").as_ptr() as _,
+                        line!() as _,
+                    ) as *mut c_char;
                     if ptr.is_null() {
                         None
                     } else {
@@ -169,7 +173,11 @@ impl Error {
     fn put_error(&self) {
         unsafe {
             ffi::ERR_new();
-            ffi::ERR_set_debug(self.file.as_ptr(), self.line, self.func.as_ref().map_or(ptr::null(), |s| s.as_ptr()));
+            ffi::ERR_set_debug(
+                self.file.as_ptr(),
+                self.line,
+                self.func.as_ref().map_or(ptr::null(), |s| s.as_ptr()),
+            );
             ffi::ERR_set_error(ffi::ERR_GET_LIB(self.code), ffi::ERR_GET_REASON(self.code), ptr::null());
         }
     }
diff --git a/crypto-glue/src/hash.rs b/crypto-glue/src/hash.rs
index 9d22143..4b24367 100644
--- a/crypto-glue/src/hash.rs
+++ b/crypto-glue/src/hash.rs
@@ -173,7 +173,13 @@ unsafe impl Send for SHA384 {}
 extern "C" {
     fn HMAC_CTX_new() -> *mut c_void;
     fn HMAC_CTX_reset(ctx: *mut c_void) -> c_int;
-    fn HMAC_Init_ex(ctx: *mut c_void, key: *const c_void, key_len: c_int, evp_md: *const c_void, _impl: *const c_void) -> c_int;
+    fn HMAC_Init_ex(
+        ctx: *mut c_void,
+        key: *const c_void,
+        key_len: c_int,
+        evp_md: *const c_void,
+        _impl: *const c_void,
+    ) -> c_int;
     fn HMAC_Update(ctx: *mut c_void, data: *const c_void, len: usize) -> c_int;
     fn HMAC_Final(ctx: *mut c_void, output: *mut c_void, output_len: *mut c_uint) -> c_int;
     fn HMAC_CTX_free(ctx: *mut c_void);
@@ -192,7 +198,10 @@ impl HMACSHA512 {
         unsafe {
             let hm = Self { ctx: HMAC_CTX_new(), evp_md: EVP_sha512() };
             assert!(!hm.ctx.is_null());
-            assert_ne!(HMAC_Init_ex(hm.ctx, key.as_ptr().cast(), key.len() as c_int, hm.evp_md, null()), 0);
+            assert_ne!(
+                HMAC_Init_ex(hm.ctx, key.as_ptr().cast(), key.len() as c_int, hm.evp_md, null()),
+                0
+            );
             hm
         }
     }
@@ -201,7 +210,10 @@ impl HMACSHA512 {
     pub fn reset(&mut self, key: &[u8]) {
         unsafe {
             assert_ne!(HMAC_CTX_reset(self.ctx), 0);
-            assert_ne!(HMAC_Init_ex(self.ctx, key.as_ptr().cast(), key.len() as c_int, self.evp_md, null()), 0);
+            assert_ne!(
+                HMAC_Init_ex(self.ctx, key.as_ptr().cast(), key.len() as c_int, self.evp_md, null()),
+                0
+            );
         }
     }
 
@@ -264,7 +276,10 @@ impl HMACSHA384 {
         unsafe {
             let hm = Self { ctx: HMAC_CTX_new(), evp_md: EVP_sha384() };
             assert!(!hm.ctx.is_null());
-            assert_ne!(HMAC_Init_ex(hm.ctx, key.as_ptr().cast(), key.len() as c_int, hm.evp_md, null()), 0);
+            assert_ne!(
+                HMAC_Init_ex(hm.ctx, key.as_ptr().cast(), key.len() as c_int, hm.evp_md, null()),
+                0
+            );
             hm
         }
     }
@@ -273,7 +288,10 @@ impl HMACSHA384 {
     pub fn reset(&mut self, key: &[u8]) {
         unsafe {
             assert_ne!(HMAC_CTX_reset(self.ctx), 0);
-            assert_ne!(HMAC_Init_ex(self.ctx, key.as_ptr().cast(), key.len() as c_int, self.evp_md, null()), 0);
+            assert_ne!(
+                HMAC_Init_ex(self.ctx, key.as_ptr().cast(), key.len() as c_int, self.evp_md, null()),
+                0
+            );
         }
     }
 
diff --git a/crypto-glue/src/p384.rs b/crypto-glue/src/p384.rs
index 890c9eb..5007632 100644
--- a/crypto-glue/src/p384.rs
+++ b/crypto-glue/src/p384.rs
@@ -26,7 +26,13 @@ pub const P384_ECDSA_SIGNATURE_SIZE: usize = 96;
 pub const P384_ECDH_SHARED_SECRET_SIZE: usize = 48;
 
 extern "C" {
-    fn ECDH_compute_key(out: *mut u8, outlen: c_ulong, pub_key: *const ffi::EC_POINT, ecdh: *mut ffi::EC_KEY, kdf: *const c_void) -> c_int;
+    fn ECDH_compute_key(
+        out: *mut u8,
+        outlen: c_ulong,
+        pub_key: *const ffi::EC_POINT,
+        ecdh: *mut ffi::EC_KEY,
+        kdf: *const c_void,
+    ) -> c_int;
 }
 /// A NIST P-384 ECDH/ECDSA public key.
 pub struct P384PublicKey {
@@ -236,7 +242,10 @@ impl P384KeyPair {
             let mut b = [0_u8; P384_ECDSA_SIGNATURE_SIZE];
             // Read the signature's raw bytes out of OpenSSL.
             ffi::BN_bn2bin(r, b[(CAP - r_len)..CAP].as_mut_ptr());
-            ffi::BN_bn2bin(s, b[(P384_ECDSA_SIGNATURE_SIZE - s_len)..P384_ECDSA_SIGNATURE_SIZE].as_mut_ptr());
+            ffi::BN_bn2bin(
+                s,
+                b[(P384_ECDSA_SIGNATURE_SIZE - s_len)..P384_ECDSA_SIGNATURE_SIZE].as_mut_ptr(),
+            );
             ffi::ECDSA_SIG_free(sig);
             b
         }
@@ -328,7 +337,13 @@ impl OSSLKey {
         let bnc = OSSLBNC::new()?;
         let point = Point::new()?;
         // Ask OpenSSL to read the raw bytes into the OpenSSL object.
-        cvt(ffi::EC_POINT_oct2point(GROUP_P384.0, point.0, buffer.as_ptr(), buffer.len(), bnc.0))?;
+        cvt(ffi::EC_POINT_oct2point(
+            GROUP_P384.0,
+            point.0,
+            buffer.as_ptr(),
+            buffer.len(),
+            bnc.0,
+        ))?;
         // Check if the object is valid.
         if cvt_n(ffi::EC_POINT_is_on_curve(GROUP_P384.0, point.0, bnc.0))? == 1 {
             // Create an OpenSSL key and guarantee to the caller that the key was initialized with a
diff --git a/crypto-glue/src/p384_builtin.rs b/crypto-glue/src/p384_builtin.rs
index 8c6ff7a..0c40773 100644
--- a/crypto-glue/src/p384_builtin.rs
+++ b/crypto-glue/src/p384_builtin.rs
@@ -262,10 +262,11 @@ mod builtin {
             };
             i = l_min;
             while i <= k && i < (48 as libc::c_int / 8 as libc::c_int) as libc::c_uint {
-                let mut l_product: uint128_t =
-                    (*p_left.offset(i as isize) as uint128_t).wrapping_mul(*p_right.offset(k.wrapping_sub(i) as isize) as u128);
+                let mut l_product: uint128_t = (*p_left.offset(i as isize) as uint128_t)
+                    .wrapping_mul(*p_right.offset(k.wrapping_sub(i) as isize) as u128);
                 r01 = (r01 as u128).wrapping_add(l_product) as uint128_t as uint128_t;
-                r2 = (r2 as libc::c_ulong).wrapping_add((r01 < l_product) as libc::c_int as libc::c_ulong) as uint64_t as uint64_t;
+                r2 = (r2 as libc::c_ulong).wrapping_add((r01 < l_product) as libc::c_int as libc::c_ulong) as uint64_t
+                    as uint64_t;
                 i = i.wrapping_add(1)
             }
             *p_result.offset(k as isize) = r01 as uint64_t;
@@ -273,7 +274,8 @@ mod builtin {
             r2 = 0 as libc::c_int as uint64_t;
             k = k.wrapping_add(1)
         }
-        *p_result.offset((48 as libc::c_int / 8 as libc::c_int * 2 as libc::c_int - 1 as libc::c_int) as isize) = r01 as uint64_t;
+        *p_result.offset((48 as libc::c_int / 8 as libc::c_int * 2 as libc::c_int - 1 as libc::c_int) as isize) =
+            r01 as uint64_t;
     }
     /* Computes p_result = p_left^2. */
 
@@ -292,14 +294,15 @@ mod builtin {
             };
             i = l_min;
             while i <= k && i <= k.wrapping_sub(i) {
-                let mut l_product: uint128_t =
-                    (*p_left.offset(i as isize) as uint128_t).wrapping_mul(*p_left.offset(k.wrapping_sub(i) as isize) as u128);
+                let mut l_product: uint128_t = (*p_left.offset(i as isize) as uint128_t)
+                    .wrapping_mul(*p_left.offset(k.wrapping_sub(i) as isize) as u128);
                 if i < k.wrapping_sub(i) {
                     r2 = (r2 as u128).wrapping_add(l_product >> 127 as libc::c_int) as uint64_t as uint64_t;
                     l_product = (l_product as u128).wrapping_mul(2 as libc::c_int as u128) as uint128_t as uint128_t
                 }
                 r01 = (r01 as u128).wrapping_add(l_product) as uint128_t as uint128_t;
-                r2 = (r2 as libc::c_ulong).wrapping_add((r01 < l_product) as libc::c_int as libc::c_ulong) as uint64_t as uint64_t;
+                r2 = (r2 as libc::c_ulong).wrapping_add((r01 < l_product) as libc::c_int as libc::c_ulong) as uint64_t
+                    as uint64_t;
                 i = i.wrapping_add(1)
             }
             *p_result.offset(k as isize) = r01 as uint64_t;
@@ -307,14 +310,20 @@ mod builtin {
             r2 = 0 as libc::c_int as uint64_t;
             k = k.wrapping_add(1)
         }
-        *p_result.offset((48 as libc::c_int / 8 as libc::c_int * 2 as libc::c_int - 1 as libc::c_int) as isize) = r01 as uint64_t;
+        *p_result.offset((48 as libc::c_int / 8 as libc::c_int * 2 as libc::c_int - 1 as libc::c_int) as isize) =
+            r01 as uint64_t;
     }
     /* #if SUPPORTS_INT128 */
     /* SUPPORTS_INT128 */
     /* Computes p_result = (p_left + p_right) % p_mod.
     Assumes that p_left < p_mod and p_right < p_mod, p_result != p_mod. */
 
-    unsafe fn vli_modAdd(mut p_result: *mut uint64_t, mut p_left: *mut uint64_t, mut p_right: *mut uint64_t, mut p_mod: *mut uint64_t) {
+    unsafe fn vli_modAdd(
+        mut p_result: *mut uint64_t,
+        mut p_left: *mut uint64_t,
+        mut p_right: *mut uint64_t,
+        mut p_mod: *mut uint64_t,
+    ) {
         let mut l_carry: uint64_t = vli_add(p_result, p_left, p_right);
         if l_carry != 0 || vli_cmp(p_result, p_mod) >= 0 as libc::c_int {
             /* p_result > p_mod (p_result = p_mod + remainder), so subtract p_mod to get remainder. */
@@ -324,7 +333,12 @@ mod builtin {
     /* Computes p_result = (p_left - p_right) % p_mod.
     Assumes that p_left < p_mod and p_right < p_mod, p_result != p_mod. */
 
-    unsafe fn vli_modSub(mut p_result: *mut uint64_t, mut p_left: *mut uint64_t, mut p_right: *mut uint64_t, mut p_mod: *mut uint64_t) {
+    unsafe fn vli_modSub(
+        mut p_result: *mut uint64_t,
+        mut p_left: *mut uint64_t,
+        mut p_right: *mut uint64_t,
+        mut p_mod: *mut uint64_t,
+    ) {
         let mut l_borrow: uint64_t = vli_sub(p_result, p_left, p_right);
         if l_borrow != 0 {
             /* In this case, p_result == -diff == (max int) - diff.
@@ -341,17 +355,19 @@ mod builtin {
         /* Multiply by (2^128 + 2^96 - 2^32 + 1). */
         vli_set(p_result, p_right); /* 1 */
         l_carry = vli_lshift(l_tmp.as_mut_ptr(), p_right, 32 as libc::c_int as uint); /* 2^96 + 1 */
-        *p_result.offset((1 as libc::c_int + 48 as libc::c_int / 8 as libc::c_int) as isize) = l_carry.wrapping_add(vli_add(
-            p_result.offset(1 as libc::c_int as isize),
-            p_result.offset(1 as libc::c_int as isize),
-            l_tmp.as_mut_ptr(),
-        )); /* 2^128 + 2^96 + 1 */
+        *p_result.offset((1 as libc::c_int + 48 as libc::c_int / 8 as libc::c_int) as isize) =
+            l_carry.wrapping_add(vli_add(
+                p_result.offset(1 as libc::c_int as isize),
+                p_result.offset(1 as libc::c_int as isize),
+                l_tmp.as_mut_ptr(),
+            )); /* 2^128 + 2^96 + 1 */
         *p_result.offset((2 as libc::c_int + 48 as libc::c_int / 8 as libc::c_int) as isize) = vli_add(
             p_result.offset(2 as libc::c_int as isize),
             p_result.offset(2 as libc::c_int as isize),
             p_right,
         ); /* 2^128 + 2^96 - 2^32 + 1 */
-        l_carry = (l_carry as libc::c_ulong).wrapping_add(vli_sub(p_result, p_result, l_tmp.as_mut_ptr())) as uint64_t as uint64_t;
+        l_carry = (l_carry as libc::c_ulong).wrapping_add(vli_sub(p_result, p_result, l_tmp.as_mut_ptr())) as uint64_t
+            as uint64_t;
         l_diff = (*p_result.offset((48 as libc::c_int / 8 as libc::c_int) as isize)).wrapping_sub(l_carry);
         if l_diff > *p_result.offset((48 as libc::c_int / 8 as libc::c_int) as isize) {
             /* Propagate borrow if necessary. */
@@ -379,13 +395,22 @@ mod builtin {
             let mut l_carry: uint64_t = 0 as libc::c_int as uint64_t; /* tmp = w * c1 */
             let mut i: uint = 0; /* p = c0 */
             vli_clear(l_tmp.as_mut_ptr());
-            vli_clear(l_tmp.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize));
-            omega_mult(l_tmp.as_mut_ptr(), p_product.offset((48 as libc::c_int / 8 as libc::c_int) as isize));
+            vli_clear(
+                l_tmp
+                    .as_mut_ptr()
+                    .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+            );
+            omega_mult(
+                l_tmp.as_mut_ptr(),
+                p_product.offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+            );
             vli_clear(p_product.offset((48 as libc::c_int / 8 as libc::c_int) as isize));
             /* (c1, c0) = c0 + w * c1 */
             i = 0 as libc::c_int as uint;
             while i < (48 as libc::c_int / 8 as libc::c_int + 3 as libc::c_int) as libc::c_uint {
-                let mut l_sum: uint64_t = (*p_product.offset(i as isize)).wrapping_add(l_tmp[i as usize]).wrapping_add(l_carry);
+                let mut l_sum: uint64_t = (*p_product.offset(i as isize))
+                    .wrapping_add(l_tmp[i as usize])
+                    .wrapping_add(l_carry);
                 if l_sum != *p_product.offset(i as isize) {
                     l_carry = (l_sum < *p_product.offset(i as isize)) as libc::c_int as uint64_t
                 }
@@ -501,7 +526,8 @@ mod builtin {
     /* Returns 1 if p_point is the point at infinity, 0 otherwise. */
 
     unsafe fn EccPoint_isZero(mut p_point: *mut EccPoint) -> libc::c_int {
-        return (vli_isZero((*p_point).x.as_mut_ptr()) != 0 && vli_isZero((*p_point).y.as_mut_ptr()) != 0) as libc::c_int;
+        return (vli_isZero((*p_point).x.as_mut_ptr()) != 0 && vli_isZero((*p_point).y.as_mut_ptr()) != 0)
+            as libc::c_int;
     }
     /* Point multiplication algorithm using Montgomery's ladder with co-Z coordinates.
     From http://eprint.iacr.org/2011/338.pdf
@@ -631,7 +657,12 @@ mod builtin {
         vli_set(X1, t7.as_mut_ptr());
     }
 
-    unsafe fn EccPoint_mult(mut p_result: *mut EccPoint, mut p_point: *mut EccPoint, mut p_scalar: *mut uint64_t, mut p_initialZ: *mut uint64_t) {
+    unsafe fn EccPoint_mult(
+        mut p_result: *mut EccPoint,
+        mut p_point: *mut EccPoint,
+        mut p_scalar: *mut uint64_t,
+        mut p_initialZ: *mut uint64_t,
+    ) {
         /* R0 and R1 */
         let mut Rx: [[uint64_t; 6]; 2] = std::mem::MaybeUninit::uninit().assume_init();
         let mut Ry: [[uint64_t; 6]; 2] = std::mem::MaybeUninit::uninit().assume_init();
@@ -678,11 +709,19 @@ mod builtin {
             Rx[0 as libc::c_int as usize].as_mut_ptr(),
             curve_p.as_mut_ptr(),
         ); /* X1 - X0 */
-        vli_modMult_fast(z.as_mut_ptr(), z.as_mut_ptr(), Ry[(1 as libc::c_int - nb) as usize].as_mut_ptr()); /* Yb * (X1 - X0) */
+        vli_modMult_fast(
+            z.as_mut_ptr(),
+            z.as_mut_ptr(),
+            Ry[(1 as libc::c_int - nb) as usize].as_mut_ptr(),
+        ); /* Yb * (X1 - X0) */
         vli_modMult_fast(z.as_mut_ptr(), z.as_mut_ptr(), (*p_point).x.as_mut_ptr()); /* xP * Yb * (X1 - X0) */
         vli_modInv(z.as_mut_ptr(), z.as_mut_ptr(), curve_p.as_mut_ptr()); /* 1 / (xP * Yb * (X1 - X0)) */
         vli_modMult_fast(z.as_mut_ptr(), z.as_mut_ptr(), (*p_point).y.as_mut_ptr()); /* yP / (xP * Yb * (X1 - X0)) */
-        vli_modMult_fast(z.as_mut_ptr(), z.as_mut_ptr(), Rx[(1 as libc::c_int - nb) as usize].as_mut_ptr()); /* Xb * yP / (xP * Yb * (X1 - X0)) */
+        vli_modMult_fast(
+            z.as_mut_ptr(),
+            z.as_mut_ptr(),
+            Rx[(1 as libc::c_int - nb) as usize].as_mut_ptr(),
+        ); /* Xb * yP / (xP * Yb * (X1 - X0)) */
         /* End 1/Z calculation */
         XYcZ_add(
             Rx[nb as usize].as_mut_ptr(),
@@ -703,12 +742,11 @@ mod builtin {
         let mut i: libc::c_uint = 0;
         i = 0 as libc::c_int as libc::c_uint;
         while i < (48 as libc::c_int / 8 as libc::c_int) as libc::c_uint {
-            let mut p_digit: *const uint8_t = p_bytes.offset(
-                (8 as libc::c_int as libc::c_uint)
-                    .wrapping_mul(((48 as libc::c_int / 8 as libc::c_int - 1 as libc::c_int) as libc::c_uint).wrapping_sub(i))
-                    as isize,
-            );
-            *p_native.offset(i as isize) = (*p_digit.offset(0 as libc::c_int as isize) as uint64_t) << 56 as libc::c_int
+            let mut p_digit: *const uint8_t = p_bytes.offset((8 as libc::c_int as libc::c_uint).wrapping_mul(
+                ((48 as libc::c_int / 8 as libc::c_int - 1 as libc::c_int) as libc::c_uint).wrapping_sub(i),
+            ) as isize);
+            *p_native.offset(i as isize) = (*p_digit.offset(0 as libc::c_int as isize) as uint64_t)
+                << 56 as libc::c_int
                 | (*p_digit.offset(1 as libc::c_int as isize) as uint64_t) << 48 as libc::c_int
                 | (*p_digit.offset(2 as libc::c_int as isize) as uint64_t) << 40 as libc::c_int
                 | (*p_digit.offset(3 as libc::c_int as isize) as uint64_t) << 32 as libc::c_int
@@ -724,11 +762,9 @@ mod builtin {
         let mut i: libc::c_uint = 0;
         i = 0 as libc::c_int as libc::c_uint;
         while i < (48 as libc::c_int / 8 as libc::c_int) as libc::c_uint {
-            let mut p_digit: *mut uint8_t = p_bytes.offset(
-                (8 as libc::c_int as libc::c_uint)
-                    .wrapping_mul(((48 as libc::c_int / 8 as libc::c_int - 1 as libc::c_int) as libc::c_uint).wrapping_sub(i))
-                    as isize,
-            );
+            let mut p_digit: *mut uint8_t = p_bytes.offset((8 as libc::c_int as libc::c_uint).wrapping_mul(
+                ((48 as libc::c_int / 8 as libc::c_int - 1 as libc::c_int) as libc::c_uint).wrapping_sub(i),
+            ) as isize);
             *p_digit.offset(0 as libc::c_int as isize) = (*p_native.offset(i as isize) >> 56 as libc::c_int) as uint8_t;
             *p_digit.offset(1 as libc::c_int as isize) = (*p_native.offset(i as isize) >> 48 as libc::c_int) as uint8_t;
             *p_digit.offset(2 as libc::c_int as isize) = (*p_native.offset(i as isize) >> 40 as libc::c_int) as uint8_t;
@@ -763,7 +799,10 @@ mod builtin {
 
     unsafe fn ecc_point_decompress(mut p_point: *mut EccPoint, mut p_compressed: *const uint8_t) {
         let mut _3: [uint64_t; 6] = [3 as libc::c_int as uint64_t, 0, 0, 0, 0, 0];
-        ecc_bytes2native((*p_point).x.as_mut_ptr(), p_compressed.offset(1 as libc::c_int as isize));
+        ecc_bytes2native(
+            (*p_point).x.as_mut_ptr(),
+            p_compressed.offset(1 as libc::c_int as isize),
+        );
         vli_modSquare_fast((*p_point).y.as_mut_ptr(), (*p_point).x.as_mut_ptr());
         vli_modSub(
             (*p_point).y.as_mut_ptr(),
@@ -771,7 +810,11 @@ mod builtin {
             _3.as_mut_ptr(),
             curve_p.as_mut_ptr(),
         );
-        vli_modMult_fast((*p_point).y.as_mut_ptr(), (*p_point).y.as_mut_ptr(), (*p_point).x.as_mut_ptr());
+        vli_modMult_fast(
+            (*p_point).y.as_mut_ptr(),
+            (*p_point).y.as_mut_ptr(),
+            (*p_point).x.as_mut_ptr(),
+        );
         vli_modAdd(
             (*p_point).y.as_mut_ptr(),
             (*p_point).y.as_mut_ptr(),
@@ -782,7 +825,11 @@ mod builtin {
         if (*p_point).y[0 as libc::c_int as usize] & 0x1 as libc::c_int as libc::c_ulong
             != (*p_compressed.offset(0 as libc::c_int as isize) as libc::c_int & 0x1 as libc::c_int) as libc::c_ulong
         {
-            vli_sub((*p_point).y.as_mut_ptr(), curve_p.as_mut_ptr(), (*p_point).y.as_mut_ptr());
+            vli_sub(
+                (*p_point).y.as_mut_ptr(),
+                curve_p.as_mut_ptr(),
+                (*p_point).y.as_mut_ptr(),
+            );
         };
     }
     pub unsafe fn ecc_make_key(mut p_publicKey: *mut uint8_t, mut p_privateKey: *mut uint8_t) -> libc::c_int {
@@ -810,12 +857,20 @@ mod builtin {
             }
         }
         ecc_native2bytes(p_privateKey, l_private.as_mut_ptr() as *const uint64_t);
-        ecc_native2bytes(p_publicKey.offset(1 as libc::c_int as isize), l_public.x.as_mut_ptr() as *const uint64_t);
-        *p_publicKey.offset(0 as libc::c_int as isize) =
-            (2 as libc::c_int as libc::c_ulong).wrapping_add(l_public.y[0 as libc::c_int as usize] & 0x1 as libc::c_int as libc::c_ulong) as uint8_t;
+        ecc_native2bytes(
+            p_publicKey.offset(1 as libc::c_int as isize),
+            l_public.x.as_mut_ptr() as *const uint64_t,
+        );
+        *p_publicKey.offset(0 as libc::c_int as isize) = (2 as libc::c_int as libc::c_ulong)
+            .wrapping_add(l_public.y[0 as libc::c_int as usize] & 0x1 as libc::c_int as libc::c_ulong)
+            as uint8_t;
         return 1 as libc::c_int;
     }
-    pub unsafe fn ecdh_shared_secret(mut p_publicKey: *const uint8_t, mut p_privateKey: *const uint8_t, mut p_secret: *mut uint8_t) -> libc::c_int {
+    pub unsafe fn ecdh_shared_secret(
+        mut p_publicKey: *const uint8_t,
+        mut p_privateKey: *const uint8_t,
+        mut p_secret: *mut uint8_t,
+    ) -> libc::c_int {
         let mut l_public: EccPoint = std::mem::MaybeUninit::uninit().assume_init();
         let mut l_private: [uint64_t; 6] = std::mem::MaybeUninit::uninit().assume_init();
         let mut l_random: [uint64_t; 6] = std::mem::MaybeUninit::uninit().assume_init();
@@ -825,14 +880,24 @@ mod builtin {
         ecc_point_decompress(&mut l_public, p_publicKey);
         ecc_bytes2native(l_private.as_mut_ptr(), p_privateKey);
         let mut l_product: EccPoint = EccPoint { x: [0; 6], y: [0; 6] };
-        EccPoint_mult(&mut l_product, &mut l_public, l_private.as_mut_ptr(), l_random.as_mut_ptr());
+        EccPoint_mult(
+            &mut l_product,
+            &mut l_public,
+            l_private.as_mut_ptr(),
+            l_random.as_mut_ptr(),
+        );
         ecc_native2bytes(p_secret, l_product.x.as_mut_ptr() as *const uint64_t);
         return (EccPoint_isZero(&mut l_product) == 0) as libc::c_int;
     }
     /* -------- ECDSA code -------- */
     /* Computes p_result = (p_left * p_right) % p_mod. */
 
-    unsafe fn vli_modMult(mut p_result: *mut uint64_t, mut p_left: *mut uint64_t, mut p_right: *mut uint64_t, mut p_mod: *mut uint64_t) {
+    unsafe fn vli_modMult(
+        mut p_result: *mut uint64_t,
+        mut p_left: *mut uint64_t,
+        mut p_right: *mut uint64_t,
+        mut p_mod: *mut uint64_t,
+    ) {
         let mut l_product: [uint64_t; 12] = std::mem::MaybeUninit::uninit().assume_init();
         let mut l_modMultiple: [uint64_t; 12] = std::mem::MaybeUninit::uninit().assume_init();
         let mut l_digitShift: uint = 0;
@@ -840,9 +905,14 @@ mod builtin {
         let mut l_productBits: uint = 0;
         let mut l_modBits: uint = vli_numBits(p_mod);
         vli_mult(l_product.as_mut_ptr(), p_left, p_right);
-        l_productBits = vli_numBits(l_product.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize));
+        l_productBits = vli_numBits(
+            l_product
+                .as_mut_ptr()
+                .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+        );
         if l_productBits != 0 {
-            l_productBits = (l_productBits as libc::c_uint).wrapping_add((48 as libc::c_int / 8 as libc::c_int * 64 as libc::c_int) as libc::c_uint)
+            l_productBits = (l_productBits as libc::c_uint)
+                .wrapping_add((48 as libc::c_int / 8 as libc::c_int * 64 as libc::c_int) as libc::c_uint)
                 as uint as uint
         } else {
             l_productBits = vli_numBits(l_product.as_mut_ptr())
@@ -855,12 +925,24 @@ mod builtin {
         /* Shift p_mod by (l_leftBits - l_modBits). This multiplies p_mod by the largest
         power of two possible while still resulting in a number less than p_left. */
         vli_clear(l_modMultiple.as_mut_ptr());
-        vli_clear(l_modMultiple.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize));
-        l_digitShift = l_productBits.wrapping_sub(l_modBits).wrapping_div(64 as libc::c_int as libc::c_uint);
-        l_bitShift = l_productBits.wrapping_sub(l_modBits).wrapping_rem(64 as libc::c_int as libc::c_uint);
+        vli_clear(
+            l_modMultiple
+                .as_mut_ptr()
+                .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+        );
+        l_digitShift = l_productBits
+            .wrapping_sub(l_modBits)
+            .wrapping_div(64 as libc::c_int as libc::c_uint);
+        l_bitShift = l_productBits
+            .wrapping_sub(l_modBits)
+            .wrapping_rem(64 as libc::c_int as libc::c_uint);
         if l_bitShift != 0 {
             l_modMultiple[l_digitShift.wrapping_add((48 as libc::c_int / 8 as libc::c_int) as libc::c_uint) as usize] =
-                vli_lshift(l_modMultiple.as_mut_ptr().offset(l_digitShift as isize), p_mod, l_bitShift)
+                vli_lshift(
+                    l_modMultiple.as_mut_ptr().offset(l_digitShift as isize),
+                    p_mod,
+                    l_bitShift,
+                )
         } else {
             vli_set(l_modMultiple.as_mut_ptr().offset(l_digitShift as isize), p_mod);
         }
@@ -871,29 +953,54 @@ mod builtin {
             || vli_cmp(l_modMultiple.as_mut_ptr(), p_mod) >= 0 as libc::c_int
         {
             let mut l_cmp: libc::c_int = vli_cmp(
-                l_modMultiple.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize),
-                l_product.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+                l_modMultiple
+                    .as_mut_ptr()
+                    .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+                l_product
+                    .as_mut_ptr()
+                    .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
             );
             if l_cmp < 0 as libc::c_int
-                || l_cmp == 0 as libc::c_int && vli_cmp(l_modMultiple.as_mut_ptr(), l_product.as_mut_ptr()) <= 0 as libc::c_int
+                || l_cmp == 0 as libc::c_int
+                    && vli_cmp(l_modMultiple.as_mut_ptr(), l_product.as_mut_ptr()) <= 0 as libc::c_int
             {
-                if vli_sub(l_product.as_mut_ptr(), l_product.as_mut_ptr(), l_modMultiple.as_mut_ptr()) != 0 {
+                if vli_sub(
+                    l_product.as_mut_ptr(),
+                    l_product.as_mut_ptr(),
+                    l_modMultiple.as_mut_ptr(),
+                ) != 0
+                {
                     /* borrow */
                     vli_sub(
-                        l_product.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize),
-                        l_product.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+                        l_product
+                            .as_mut_ptr()
+                            .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+                        l_product
+                            .as_mut_ptr()
+                            .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
                         p_result,
                     );
                 }
                 vli_sub(
-                    l_product.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize),
-                    l_product.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize),
-                    l_modMultiple.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+                    l_product
+                        .as_mut_ptr()
+                        .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+                    l_product
+                        .as_mut_ptr()
+                        .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+                    l_modMultiple
+                        .as_mut_ptr()
+                        .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
                 );
             }
-            let mut l_carry: uint64_t =
-                (l_modMultiple[(48 as libc::c_int / 8 as libc::c_int) as usize] & 0x1 as libc::c_int as libc::c_ulong) << 63 as libc::c_int;
-            vli_rshift1(l_modMultiple.as_mut_ptr().offset((48 as libc::c_int / 8 as libc::c_int) as isize));
+            let mut l_carry: uint64_t = (l_modMultiple[(48 as libc::c_int / 8 as libc::c_int) as usize]
+                & 0x1 as libc::c_int as libc::c_ulong)
+                << 63 as libc::c_int;
+            vli_rshift1(
+                l_modMultiple
+                    .as_mut_ptr()
+                    .offset((48 as libc::c_int / 8 as libc::c_int) as isize),
+            );
             vli_rshift1(l_modMultiple.as_mut_ptr());
             l_modMultiple[(48 as libc::c_int / 8 as libc::c_int - 1 as libc::c_int) as usize] |= l_carry;
             l_productBits = l_productBits.wrapping_sub(1)
@@ -904,7 +1011,11 @@ mod builtin {
     unsafe fn umax(mut a: uint, mut b: uint) -> uint {
         a.max(b)
     }
-    pub unsafe fn ecdsa_sign(mut p_privateKey: *const uint8_t, mut p_hash: *const uint8_t, mut p_signature: *mut uint8_t) -> libc::c_int {
+    pub unsafe fn ecdsa_sign(
+        mut p_privateKey: *const uint8_t,
+        mut p_hash: *const uint8_t,
+        mut p_signature: *mut uint8_t,
+    ) -> libc::c_int {
         let mut k: [uint64_t; 6] = std::mem::MaybeUninit::uninit().assume_init();
         let mut l_tmp: [uint64_t; 6] = std::mem::MaybeUninit::uninit().assume_init();
         let mut l_s: [uint64_t; 6] = std::mem::MaybeUninit::uninit().assume_init();
@@ -936,15 +1047,32 @@ mod builtin {
         } /* s = (e + r*d) / k */
         ecc_native2bytes(p_signature, p.x.as_mut_ptr() as *const uint64_t);
         ecc_bytes2native(l_tmp.as_mut_ptr(), p_privateKey);
-        vli_modMult(l_s.as_mut_ptr(), p.x.as_mut_ptr(), l_tmp.as_mut_ptr(), curve_n.as_mut_ptr());
+        vli_modMult(
+            l_s.as_mut_ptr(),
+            p.x.as_mut_ptr(),
+            l_tmp.as_mut_ptr(),
+            curve_n.as_mut_ptr(),
+        );
         ecc_bytes2native(l_tmp.as_mut_ptr(), p_hash);
-        vli_modAdd(l_s.as_mut_ptr(), l_tmp.as_mut_ptr(), l_s.as_mut_ptr(), curve_n.as_mut_ptr());
+        vli_modAdd(
+            l_s.as_mut_ptr(),
+            l_tmp.as_mut_ptr(),
+            l_s.as_mut_ptr(),
+            curve_n.as_mut_ptr(),
+        );
         vli_modInv(k.as_mut_ptr(), k.as_mut_ptr(), curve_n.as_mut_ptr());
         vli_modMult(l_s.as_mut_ptr(), l_s.as_mut_ptr(), k.as_mut_ptr(), curve_n.as_mut_ptr());
-        ecc_native2bytes(p_signature.offset(48 as libc::c_int as isize), l_s.as_mut_ptr() as *const uint64_t);
+        ecc_native2bytes(
+            p_signature.offset(48 as libc::c_int as isize),
+            l_s.as_mut_ptr() as *const uint64_t,
+        );
         return 1 as libc::c_int;
     }
-    pub unsafe fn ecdsa_verify(mut p_publicKey: *const uint8_t, mut p_hash: *const uint8_t, mut p_signature: *const uint8_t) -> libc::c_int {
+    pub unsafe fn ecdsa_verify(
+        mut p_publicKey: *const uint8_t,
+        mut p_hash: *const uint8_t,
+        mut p_signature: *const uint8_t,
+    ) -> libc::c_int {
         let mut u1: [uint64_t; 6] = std::mem::MaybeUninit::uninit().assume_init();
         let mut u2: [uint64_t; 6] = std::mem::MaybeUninit::uninit().assume_init();
         let mut z: [uint64_t; 6] = std::mem::MaybeUninit::uninit().assume_init();
@@ -964,7 +1092,8 @@ mod builtin {
             /* r, s must not be 0. */
             return 0 as libc::c_int;
         }
-        if vli_cmp(curve_n.as_mut_ptr(), l_r.as_mut_ptr()) != 1 as libc::c_int || vli_cmp(curve_n.as_mut_ptr(), l_s.as_mut_ptr()) != 1 as libc::c_int
+        if vli_cmp(curve_n.as_mut_ptr(), l_r.as_mut_ptr()) != 1 as libc::c_int
+            || vli_cmp(curve_n.as_mut_ptr(), l_s.as_mut_ptr()) != 1 as libc::c_int
         {
             /* r, s must be < n. */
             return 0 as libc::c_int;
@@ -979,17 +1108,32 @@ mod builtin {
         vli_set(l_sum.y.as_mut_ptr(), l_public.y.as_mut_ptr()); /* Z = 1/Z */
         vli_set(tx.as_mut_ptr(), curve_G.x.as_mut_ptr());
         vli_set(ty.as_mut_ptr(), curve_G.y.as_mut_ptr());
-        vli_modSub(z.as_mut_ptr(), l_sum.x.as_mut_ptr(), tx.as_mut_ptr(), curve_p.as_mut_ptr());
-        XYcZ_add(tx.as_mut_ptr(), ty.as_mut_ptr(), l_sum.x.as_mut_ptr(), l_sum.y.as_mut_ptr());
+        vli_modSub(
+            z.as_mut_ptr(),
+            l_sum.x.as_mut_ptr(),
+            tx.as_mut_ptr(),
+            curve_p.as_mut_ptr(),
+        );
+        XYcZ_add(
+            tx.as_mut_ptr(),
+            ty.as_mut_ptr(),
+            l_sum.x.as_mut_ptr(),
+            l_sum.y.as_mut_ptr(),
+        );
         vli_modInv(z.as_mut_ptr(), z.as_mut_ptr(), curve_p.as_mut_ptr());
         apply_z(l_sum.x.as_mut_ptr(), l_sum.y.as_mut_ptr(), z.as_mut_ptr());
         /* Use Shamir's trick to calculate u1*G + u2*Q */
         let mut l_points: [*mut EccPoint; 4] = [0 as *mut EccPoint, &mut curve_G, &mut l_public, &mut l_sum]; /* Z = x2 - x1 */
         let mut l_numBits: uint = umax(vli_numBits(u1.as_mut_ptr()), vli_numBits(u2.as_mut_ptr())); /* Z = 1/Z */
-        let mut l_point: *mut EccPoint = l_points[((vli_testBit(u1.as_mut_ptr(), l_numBits.wrapping_sub(1 as libc::c_int as libc::c_uint)) != 0)
-            as libc::c_int
-            | ((vli_testBit(u2.as_mut_ptr(), l_numBits.wrapping_sub(1 as libc::c_int as libc::c_uint)) != 0) as libc::c_int) << 1 as libc::c_int)
-            as usize];
+        let mut l_point: *mut EccPoint = l_points[((vli_testBit(
+            u1.as_mut_ptr(),
+            l_numBits.wrapping_sub(1 as libc::c_int as libc::c_uint),
+        ) != 0) as libc::c_int
+            | ((vli_testBit(
+                u2.as_mut_ptr(),
+                l_numBits.wrapping_sub(1 as libc::c_int as libc::c_uint),
+            ) != 0) as libc::c_int)
+                << 1 as libc::c_int) as usize];
         vli_set(rx.as_mut_ptr(), (*l_point).x.as_mut_ptr());
         vli_set(ry.as_mut_ptr(), (*l_point).y.as_mut_ptr());
         vli_clear(z.as_mut_ptr());
@@ -1036,7 +1180,11 @@ mod builtin {
         pub fn verify(&self, msg: &[u8], signature: &[u8]) -> bool {
             if signature.len() == 96 {
                 unsafe {
-                    return ecdsa_verify(self.0.as_ptr().cast(), SHA384::hash(msg).as_ptr().cast(), signature.as_ptr().cast()) != 0;
+                    return ecdsa_verify(
+                        self.0.as_ptr().cast(),
+                        SHA384::hash(msg).as_ptr().cast(),
+                        signature.as_ptr().cast(),
+                    ) != 0;
                 }
             }
             return false;
@@ -1092,7 +1240,11 @@ mod builtin {
         pub fn agree(&self, other_public: &P384PublicKey) -> Option<Secret<48>> {
             let mut k = Secret::new();
             unsafe {
-                ecdh_shared_secret(other_public.0.as_ptr().cast(), self.1 .0.as_ptr().cast(), k.0.as_mut_ptr().cast());
+                ecdh_shared_secret(
+                    other_public.0.as_ptr().cast(),
+                    self.1 .0.as_ptr().cast(),
+                    k.0.as_mut_ptr().cast(),
+                );
             }
             Some(k)
         }
diff --git a/crypto-glue/src/poly1305.rs b/crypto-glue/src/poly1305.rs
index 3a50878..0655213 100644
--- a/crypto-glue/src/poly1305.rs
+++ b/crypto-glue/src/poly1305.rs
@@ -26,12 +26,12 @@ mod tests {
     use crate::poly1305::*;
 
     const TV0_INPUT: [u8; 32] = [
-        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, 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, 0x00, 0x00,
     ];
     const TV0_KEY: [u8; 32] = [
-        0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x33, 0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x66, 0x6f, 0x72,
-        0x20, 0x50, 0x6f, 0x6c, 0x79, 0x31, 0x33, 0x30, 0x35,
+        0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x33, 0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b, 0x65,
+        0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x50, 0x6f, 0x6c, 0x79, 0x31, 0x33, 0x30, 0x35,
     ];
     const TV0_TAG: [u8; 16] = [
         0x49, 0xec, 0x78, 0x09, 0x0e, 0x48, 0x1e, 0xc6, 0xc2, 0x6b, 0x33, 0xb9, 0x1c, 0xcc, 0x03, 0x07,
@@ -39,8 +39,8 @@ mod tests {
 
     const TV1_INPUT: [u8; 12] = [0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x21];
     const TV1_KEY: [u8; 32] = [
-        0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x33, 0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x66, 0x6f, 0x72,
-        0x20, 0x50, 0x6f, 0x6c, 0x79, 0x31, 0x33, 0x30, 0x35,
+        0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x33, 0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b, 0x65,
+        0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x50, 0x6f, 0x6c, 0x79, 0x31, 0x33, 0x30, 0x35,
     ];
     const TV1_TAG: [u8; 16] = [
         0xa6, 0xf7, 0x45, 0x00, 0x8f, 0x81, 0xc9, 0x16, 0xa2, 0x0d, 0xcc, 0x74, 0xee, 0xf2, 0xb2, 0xf0,
diff --git a/crypto-glue/src/salsa.rs b/crypto-glue/src/salsa.rs
index 5542dd2..100e2dc 100644
--- a/crypto-glue/src/salsa.rs
+++ b/crypto-glue/src/salsa.rs
@@ -166,12 +166,18 @@ impl<const ROUNDS: usize> Salsa<ROUNDS> {
                         *ciphertext.as_mut_ptr().cast::<u32>().add(7) = *plaintext.as_ptr().cast::<u32>().add(7) ^ x7;
                         *ciphertext.as_mut_ptr().cast::<u32>().add(8) = *plaintext.as_ptr().cast::<u32>().add(8) ^ x8;
                         *ciphertext.as_mut_ptr().cast::<u32>().add(9) = *plaintext.as_ptr().cast::<u32>().add(9) ^ x9;
-                        *ciphertext.as_mut_ptr().cast::<u32>().add(10) = *plaintext.as_ptr().cast::<u32>().add(10) ^ x10;
-                        *ciphertext.as_mut_ptr().cast::<u32>().add(11) = *plaintext.as_ptr().cast::<u32>().add(11) ^ x11;
-                        *ciphertext.as_mut_ptr().cast::<u32>().add(12) = *plaintext.as_ptr().cast::<u32>().add(12) ^ x12;
-                        *ciphertext.as_mut_ptr().cast::<u32>().add(13) = *plaintext.as_ptr().cast::<u32>().add(13) ^ x13;
-                        *ciphertext.as_mut_ptr().cast::<u32>().add(14) = *plaintext.as_ptr().cast::<u32>().add(14) ^ x14;
-                        *ciphertext.as_mut_ptr().cast::<u32>().add(15) = *plaintext.as_ptr().cast::<u32>().add(15) ^ x15;
+                        *ciphertext.as_mut_ptr().cast::<u32>().add(10) =
+                            *plaintext.as_ptr().cast::<u32>().add(10) ^ x10;
+                        *ciphertext.as_mut_ptr().cast::<u32>().add(11) =
+                            *plaintext.as_ptr().cast::<u32>().add(11) ^ x11;
+                        *ciphertext.as_mut_ptr().cast::<u32>().add(12) =
+                            *plaintext.as_ptr().cast::<u32>().add(12) ^ x12;
+                        *ciphertext.as_mut_ptr().cast::<u32>().add(13) =
+                            *plaintext.as_ptr().cast::<u32>().add(13) ^ x13;
+                        *ciphertext.as_mut_ptr().cast::<u32>().add(14) =
+                            *plaintext.as_ptr().cast::<u32>().add(14) ^ x14;
+                        *ciphertext.as_mut_ptr().cast::<u32>().add(15) =
+                            *plaintext.as_ptr().cast::<u32>().add(15) ^ x15;
                     }
                 }
                 #[cfg(not(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64")))]
@@ -248,14 +254,15 @@ mod tests {
     use crate::salsa::*;
 
     const SALSA_20_TV0_KEY: [u8; 32] = [
-        0x0f, 0x62, 0xb5, 0x08, 0x5b, 0xae, 0x01, 0x54, 0xa7, 0xfa, 0x4d, 0xa0, 0xf3, 0x46, 0x99, 0xec, 0x3f, 0x92, 0xe5, 0x38, 0x8b, 0xde, 0x31,
-        0x84, 0xd7, 0x2a, 0x7d, 0xd0, 0x23, 0x76, 0xc9, 0x1c,
+        0x0f, 0x62, 0xb5, 0x08, 0x5b, 0xae, 0x01, 0x54, 0xa7, 0xfa, 0x4d, 0xa0, 0xf3, 0x46, 0x99, 0xec, 0x3f, 0x92,
+        0xe5, 0x38, 0x8b, 0xde, 0x31, 0x84, 0xd7, 0x2a, 0x7d, 0xd0, 0x23, 0x76, 0xc9, 0x1c,
     ];
     const SALSA_20_TV0_IV: [u8; 8] = [0x28, 0x8f, 0xf6, 0x5d, 0xc4, 0x2b, 0x92, 0xf9];
     const SALSA_20_TV0_KS: [u8; 64] = [
-        0x5e, 0x5e, 0x71, 0xf9, 0x01, 0x99, 0x34, 0x03, 0x04, 0xab, 0xb2, 0x2a, 0x37, 0xb6, 0x62, 0x5b, 0xf8, 0x83, 0xfb, 0x89, 0xce, 0x3b, 0x21,
-        0xf5, 0x4a, 0x10, 0xb8, 0x10, 0x66, 0xef, 0x87, 0xda, 0x30, 0xb7, 0x76, 0x99, 0xaa, 0x73, 0x79, 0xda, 0x59, 0x5c, 0x77, 0xdd, 0x59, 0x54,
-        0x2d, 0xa2, 0x08, 0xe5, 0x95, 0x4f, 0x89, 0xe4, 0x0e, 0xb7, 0xaa, 0x80, 0xa8, 0x4a, 0x61, 0x76, 0x66, 0x3f,
+        0x5e, 0x5e, 0x71, 0xf9, 0x01, 0x99, 0x34, 0x03, 0x04, 0xab, 0xb2, 0x2a, 0x37, 0xb6, 0x62, 0x5b, 0xf8, 0x83,
+        0xfb, 0x89, 0xce, 0x3b, 0x21, 0xf5, 0x4a, 0x10, 0xb8, 0x10, 0x66, 0xef, 0x87, 0xda, 0x30, 0xb7, 0x76, 0x99,
+        0xaa, 0x73, 0x79, 0xda, 0x59, 0x5c, 0x77, 0xdd, 0x59, 0x54, 0x2d, 0xa2, 0x08, 0xe5, 0x95, 0x4f, 0x89, 0xe4,
+        0x0e, 0xb7, 0xaa, 0x80, 0xa8, 0x4a, 0x61, 0x76, 0x66, 0x3f,
     ];
 
     #[test]
diff --git a/crypto-glue/src/x25519.rs b/crypto-glue/src/x25519.rs
index 9d7599d..f982fb0 100644
--- a/crypto-glue/src/x25519.rs
+++ b/crypto-glue/src/x25519.rs
@@ -159,7 +159,10 @@ impl Ed25519KeyPair {
 
 impl Clone for Ed25519KeyPair {
     fn clone(&self) -> Self {
-        Self(ed25519_dalek::Keypair::from_bytes(&self.0.to_bytes()).unwrap(), self.1.clone())
+        Self(
+            ed25519_dalek::Keypair::from_bytes(&self.0.to_bytes()).unwrap(),
+            self.1.clone(),
+        )
     }
 }
 
@@ -169,7 +172,8 @@ pub fn ed25519_verify(public_key: &[u8], signature: &[u8], msg: &[u8]) -> bool {
             let mut h = ed25519_dalek::Sha512::new();
             let _ = h.write_all(msg);
             let sig: [u8; 64] = signature[0..64].try_into().unwrap();
-            pk.verify_prehashed(h, None, &ed25519_dalek::Signature::from(sig)).is_ok()
+            pk.verify_prehashed(h, None, &ed25519_dalek::Signature::from(sig))
+                .is_ok()
         })
     } else {
         false
diff --git a/rustfmt.toml b/rustfmt.toml
index c532918..9b1e1ee 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1,5 +1,5 @@
 #unstable_features = true
-max_width = 150
+max_width = 120
 #use_small_heuristics = "Max"
 edition = "2021"
 #empty_item_single_line = true