diff --git a/CMakeLists.txt b/CMakeLists.txt
index aac11c2..0d30d8d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -97,9 +97,7 @@ if(NOT USE_TERNARY)
   endif()
 endif()
 
-
-# if(USE_AVX512)
-  # string(APPEND CMAKE_CXX_FLAGS " -mprefer-vector-width=512")
+# if(USE_AVX512) string(APPEND CMAKE_CXX_FLAGS " -mprefer-vector-width=512")
 # endif()
 
 if(USE_FFTW3)
diff --git a/include/circuitbootstrapping.hpp b/include/circuitbootstrapping.hpp
index a764529..8406a78 100644
--- a/include/circuitbootstrapping.hpp
+++ b/include/circuitbootstrapping.hpp
@@ -26,7 +26,8 @@ void CircuitBootstrapping(TRGSW<typename privksP::targetP> &trgsw,
                           const TLWE<typename bkP::domainP> &tlwe,
                           const EvalKey &ek)
 {
-    alignas(64) std::array<TLWE<typename bkP::targetP>, privksP::targetP::l> temp;
+    alignas(64) std::array<TLWE<typename bkP::targetP>, privksP::targetP::l>
+        temp;
     GateBootstrappingManyLUT<bkP, privksP::targetP::l>(
         temp, tlwe, ek.getbkfft<bkP>(), CBtestvector<privksP>());
     for (int i = 0; i < privksP::targetP::l; i++) {
@@ -81,7 +82,8 @@ void CircuitBootstrappingSub(TRGSW<typename privksP::targetP> &trgsw,
 {
     alignas(64) TLWE<typename bkP::domainP> tlwelvl0;
     IdentityKeySwitch<iksP>(tlwelvl0, tlwe, ek.getiksk<iksP>());
-    alignas(64) std::array<TLWE<typename bkP::targetP>, privksP::targetP::l> temp;
+    alignas(64) std::array<TLWE<typename bkP::targetP>, privksP::targetP::l>
+        temp;
     GateBootstrappingManyLUT<bkP, privksP::targetP::l>(
         temp, tlwelvl0, ek.getbkfft<bkP>(), CBtestvector<privksP>());
     for (int i = 0; i < privksP::targetP::l; i++) {
diff --git a/include/cloudkey.hpp b/include/cloudkey.hpp
index c0e613b..ac4a15d 100644
--- a/include/cloudkey.hpp
+++ b/include/cloudkey.hpp
@@ -416,19 +416,23 @@ struct EvalKey {
     void emplacebkfft(const SecretKey& sk)
     {
         if constexpr (std::is_same_v<P, lvl01param>) {
-            bkfftlvl01 = std::unique_ptr<BootstrappingKeyFFT<lvl01param>>(new (std::align_val_t(64)) BootstrappingKeyFFT<lvl01param>());
+            bkfftlvl01 = std::unique_ptr<BootstrappingKeyFFT<lvl01param>>(
+                new (std::align_val_t(64)) BootstrappingKeyFFT<lvl01param>());
             bkfftgen<lvl01param>(*bkfftlvl01, sk);
         }
         else if constexpr (std::is_same_v<P, lvlh1param>) {
-            bkfftlvlh1 = std::unique_ptr<BootstrappingKeyFFT<lvlh1param>>(new (std::align_val_t(64)) BootstrappingKeyFFT<lvlh1param>());
+            bkfftlvlh1 = std::unique_ptr<BootstrappingKeyFFT<lvlh1param>>(
+                new (std::align_val_t(64)) BootstrappingKeyFFT<lvlh1param>());
             bkfftgen<lvlh1param>(*bkfftlvlh1, sk);
         }
         else if constexpr (std::is_same_v<P, lvl02param>) {
-            bkfftlvl02 = std::unique_ptr<BootstrappingKeyFFT<lvl02param>>(new (std::align_val_t(64)) BootstrappingKeyFFT<lvl02param>());
+            bkfftlvl02 = std::unique_ptr<BootstrappingKeyFFT<lvl02param>>(
+                new (std::align_val_t(64)) BootstrappingKeyFFT<lvl02param>());
             bkfftgen<lvl02param>(*bkfftlvl02, sk);
         }
         else if constexpr (std::is_same_v<P, lvlh2param>) {
-            bkfftlvlh2 = std::unique_ptr<BootstrappingKeyFFT<lvlh2param>>(new (std::align_val_t(64)) BootstrappingKeyFFT<lvlh2param>());
+            bkfftlvlh2 = std::unique_ptr<BootstrappingKeyFFT<lvlh2param>>(
+                new (std::align_val_t(64)) BootstrappingKeyFFT<lvlh2param>());
             bkfftgen<lvlh2param>(*bkfftlvlh2, sk);
         }
         else
@@ -528,15 +532,18 @@ struct EvalKey {
     void emplaceiksk(const SecretKey& sk)
     {
         if constexpr (std::is_same_v<P, lvl10param>) {
-            iksklvl10 = std::unique_ptr<KeySwitchingKey<lvl10param>>(new (std::align_val_t(64)) KeySwitchingKey<lvl10param>());
+            iksklvl10 = std::unique_ptr<KeySwitchingKey<lvl10param>>(
+                new (std::align_val_t(64)) KeySwitchingKey<lvl10param>());
             ikskgen<lvl10param>(*iksklvl10, sk);
         }
         else if constexpr (std::is_same_v<P, lvl1hparam>) {
-            iksklvl1h = std::unique_ptr<KeySwitchingKey<lvl1hparam>>(new (std::align_val_t(64)) KeySwitchingKey<lvl1hparam>());
+            iksklvl1h = std::unique_ptr<KeySwitchingKey<lvl1hparam>>(
+                new (std::align_val_t(64)) KeySwitchingKey<lvl1hparam>());
             ikskgen<lvl1hparam>(*iksklvl1h, sk);
         }
         else if constexpr (std::is_same_v<P, lvl20param>) {
-            iksklvl20 = std::unique_ptr<KeySwitchingKey<lvl20param>>(new (std::align_val_t(64)) KeySwitchingKey<lvl20param>());
+            iksklvl20 = std::unique_ptr<KeySwitchingKey<lvl20param>>(
+                new (std::align_val_t(64)) KeySwitchingKey<lvl20param>());
             ikskgen<lvl20param>(*iksklvl20, sk);
         }
         // else if constexpr (std::is_same_v<P, lvl2hparam>) {
@@ -545,15 +552,18 @@ struct EvalKey {
         //     ikskgen<lvlh2param>(*iksklvlh2, sk);
         // }
         else if constexpr (std::is_same_v<P, lvl21param>) {
-            iksklvl21 = std::unique_ptr<KeySwitchingKey<lvl21param>>(new (std::align_val_t(64)) KeySwitchingKey<lvl21param>());
+            iksklvl21 = std::unique_ptr<KeySwitchingKey<lvl21param>>(
+                new (std::align_val_t(64)) KeySwitchingKey<lvl21param>());
             ikskgen<lvl21param>(*iksklvl21, sk);
         }
         else if constexpr (std::is_same_v<P, lvl22param>) {
-            iksklvl22 = std::unique_ptr<KeySwitchingKey<lvl22param>>(new (std::align_val_t(64)) KeySwitchingKey<lvl22param>());
+            iksklvl22 = std::unique_ptr<KeySwitchingKey<lvl22param>>(
+                new (std::align_val_t(64)) KeySwitchingKey<lvl22param>());
             ikskgen<lvl22param>(*iksklvl22, sk);
         }
         else if constexpr (std::is_same_v<P, lvl31param>) {
-            iksklvl31 = std::unique_ptr<KeySwitchingKey<lvl31param>>(new (std::align_val_t(64)) KeySwitchingKey<lvl31param>());
+            iksklvl31 = std::unique_ptr<KeySwitchingKey<lvl31param>>(
+                new (std::align_val_t(64)) KeySwitchingKey<lvl31param>());
             ikskgen<lvl31param>(*iksklvl31, sk);
         }
         else
@@ -576,15 +586,21 @@ struct EvalKey {
                         const SecretKey& sk)
     {
         if constexpr (std::is_same_v<P, lvl11param>) {
-            privksklvl11[key] = std::unique_ptr<PrivateKeySwitchingKey<lvl11param>>(new (std::align_val_t(64)) PrivateKeySwitchingKey<lvl11param>());
+            privksklvl11[key] =
+                std::unique_ptr<PrivateKeySwitchingKey<lvl11param>>(new (
+                    std::align_val_t(64)) PrivateKeySwitchingKey<lvl11param>());
             privkskgen<lvl11param>(*privksklvl11[key], func, sk);
         }
         else if constexpr (std::is_same_v<P, lvl21param>) {
-            privksklvl21[key] = std::unique_ptr<PrivateKeySwitchingKey<lvl21param>>(new (std::align_val_t(64)) PrivateKeySwitchingKey<lvl21param>());
+            privksklvl21[key] =
+                std::unique_ptr<PrivateKeySwitchingKey<lvl21param>>(new (
+                    std::align_val_t(64)) PrivateKeySwitchingKey<lvl21param>());
             privkskgen<lvl21param>(*privksklvl21[key], func, sk);
         }
         else if constexpr (std::is_same_v<P, lvl22param>) {
-            privksklvl22[key] = std::unique_ptr<PrivateKeySwitchingKey<lvl22param>>(new (std::align_val_t(64)) PrivateKeySwitchingKey<lvl22param>());
+            privksklvl22[key] =
+                std::unique_ptr<PrivateKeySwitchingKey<lvl22param>>(new (
+                    std::align_val_t(64)) PrivateKeySwitchingKey<lvl22param>());
             privkskgen<lvl22param>(*privksklvl22[key], func, sk);
         }
         else
diff --git a/include/mulfft.hpp b/include/mulfft.hpp
index f570e54..db49ca9 100644
--- a/include/mulfft.hpp
+++ b/include/mulfft.hpp
@@ -95,10 +95,10 @@ inline void TwistFFT(Polynomial<P> &res, const PolynomialInFD<P> &a)
 template <class P>
 inline void TwistFFTrescale(Polynomial<P> &res, const PolynomialInFD<P> &a)
 {
-    if constexpr (std::is_same_v<P, lvl1param>){
-        if constexpr(std::is_same_v<typename P::T, uint32_t>)
+    if constexpr (std::is_same_v<P, lvl1param>) {
+        if constexpr (std::is_same_v<typename P::T, uint32_t>)
             fftplvl1.execute_direct_torus32_rescale(res.data(), a.data(), P::Δ);
-        else if constexpr(std::is_same_v<typename P::T, uint64_t>)
+        else if constexpr (std::is_same_v<typename P::T, uint64_t>)
             fftplvl1.execute_direct_torus64_rescale(res.data(), a.data(), P::Δ);
     }
     else if constexpr (std::is_same_v<P, lvl2param>)
@@ -147,33 +147,35 @@ inline void TwistIFFT(PolynomialInFD<P> &res, const Polynomial<P> &a)
 template <uint32_t N>
 inline void MulInFD(std::array<double, N> &res, const std::array<double, N> &b)
 {
-    #ifdef USE_INTERLEAVED_FORMAT
-    for(int i = 0; i < N / 2; i++){
-        const std::complex tmp = std::complex(res[2*i], res[2*i+1]) * std::complex(b[2*i], b[2*i+1]);
-        res[2*i] = tmp.real();
-        res[2*i+1] = tmp.imag();
+#ifdef USE_INTERLEAVED_FORMAT
+    for (int i = 0; i < N / 2; i++) {
+        const std::complex tmp = std::complex(res[2 * i], res[2 * i + 1]) *
+                                 std::complex(b[2 * i], b[2 * i + 1]);
+        res[2 * i] = tmp.real();
+        res[2 * i + 1] = tmp.imag();
     }
-    #else
+#else
     for (int i = 0; i < N / 2; i++) {
         double aimbim = res[i + N / 2] * b[i + N / 2];
         double arebim = res[i] * b[i + N / 2];
         res[i] = std::fma(res[i], b[i], -aimbim);
         res[i + N / 2] = std::fma(res[i + N / 2], b[i], arebim);
     }
-    #endif
+#endif
 }
 
 template <uint32_t N>
 inline void MulInFD(std::array<double, N> &res, const std::array<double, N> &a,
                     const std::array<double, N> &b)
 {
-    #ifdef USE_INTERLEAVED_FORMAT
-    for(int i = 0; i < N / 2; i++){
-        const std::complex tmp = std::complex(a[2*i], a[2*i+1]) * std::complex(b[2*i], b[2*i+1]);
-        res[2*i] = tmp.real();
-        res[2*i+1] = tmp.imag();
+#ifdef USE_INTERLEAVED_FORMAT
+    for (int i = 0; i < N / 2; i++) {
+        const std::complex tmp = std::complex(a[2 * i], a[2 * i + 1]) *
+                                 std::complex(b[2 * i], b[2 * i + 1]);
+        res[2 * i] = tmp.real();
+        res[2 * i + 1] = tmp.imag();
     }
-    #else
+#else
     // for (int i = 0; i < N / 2; i++) {
     //     double aimbim = a[i + N / 2] * b[i + N / 2];
     //     double arebim = a[i] * b[i + N / 2];
@@ -205,7 +207,7 @@ inline void MulInFD(std::array<double, N> &res, const std::array<double, N> &a,
         res[i + N / 2] += a[i] * b[i + N / 2];
         res[i] -= a[i + N / 2] * b[i + N / 2];
     }
-    #endif
+#endif
 }
 
 // Be careful about memory accesss (We assume b has relatively high memory
@@ -214,13 +216,14 @@ template <uint32_t N>
 inline void FMAInFD(std::array<double, N> &res, const std::array<double, N> &a,
                     const std::array<double, N> &b)
 {
-    #ifdef USE_INTERLEAVED_FORMAT
-    for(int i = 0; i < N / 2; i++){
-        std::complex tmp = std::complex(a[2*i], a[2*i+1]) * std::complex(b[2*i], b[2*i+1]);
-        res[2*i] += tmp.real();
-        res[2*i+1] += tmp.imag();
+#ifdef USE_INTERLEAVED_FORMAT
+    for (int i = 0; i < N / 2; i++) {
+        std::complex tmp = std::complex(a[2 * i], a[2 * i + 1]) *
+                           std::complex(b[2 * i], b[2 * i + 1]);
+        res[2 * i] += tmp.real();
+        res[2 * i + 1] += tmp.imag();
     }
-    #else
+#else
     for (int i = 0; i < N / 2; i++) {
         res[i] = std::fma(a[i], b[i], res[i]);
         res[i + N / 2] = std::fma(a[i + N / 2], b[i], res[i + N / 2]);
@@ -229,13 +232,13 @@ inline void FMAInFD(std::array<double, N> &res, const std::array<double, N> &a,
         res[i + N / 2] = std::fma(a[i], b[i + N / 2], res[i + N / 2]);
         res[i] -= a[i + N / 2] * b[i + N / 2];
     }
-    // for (int i = 0; i < N / 2; i++) {
-    //     res[i] = std::fma(a[i + N / 2], b[i + N / 2], -res[i]);
-    //     res[i] = std::fma(a[i], b[i], -res[i]);
-    //     res[i + N / 2] = std::fma(a[i], b[i + N / 2], res[i + N / 2]);
-    //     res[i + N / 2] = std::fma(a[i + N / 2], b[i], res[i + N / 2]);
-    // }
-    #endif
+// for (int i = 0; i < N / 2; i++) {
+//     res[i] = std::fma(a[i + N / 2], b[i + N / 2], -res[i]);
+//     res[i] = std::fma(a[i], b[i], -res[i]);
+//     res[i + N / 2] = std::fma(a[i], b[i + N / 2], res[i + N / 2]);
+//     res[i + N / 2] = std::fma(a[i + N / 2], b[i], res[i + N / 2]);
+// }
+#endif
 }
 
 template <class P>
@@ -302,11 +305,11 @@ inline void PolyMulRescaleUnsigned(Polynomial<P> &res,
                                    const UnsignedPolynomial<P> &b)
 {
     // if constexpr (std::is_same_v<typename P::T, uint32_t>) {
-        PolynomialInFD<P> ffta, fftb;
-        TwistIFFT<P>(ffta, a);
-        TwistIFFT<P>(fftb, b);
-        MulInFD<P::n>(ffta, ffta, fftb);
-        TwistFFTrescale<P>(res, ffta);
+    PolynomialInFD<P> ffta, fftb;
+    TwistIFFT<P>(ffta, a);
+    TwistIFFT<P>(fftb, b);
+    MulInFD<P::n>(ffta, ffta, fftb);
+    TwistFFTrescale<P>(res, ffta);
     // }
     // else
     //     static_assert(false_v<typename P::T>, "Undefined PolyMul!");
@@ -333,7 +336,7 @@ inline void PolyMulNaive(Polynomial<P> &res, const Polynomial<P> &a,
 template <class P>
 std::unique_ptr<std::array<PolynomialInFD<P>, 2 * P::n>> XaittGen()
 {
-    std::unique_ptr<std::array<PolynomialInFD<P>, 2 *P::n>> xaitt =
+    std::unique_ptr<std::array<PolynomialInFD<P>, 2 * P::n>> xaitt =
         std::make_unique<std::array<PolynomialInFD<P>, 2 * P::n>>();
     for (int i = 0; i < 2 * P::n; i++) {
         std::array<typename P::T, P::n> xai = {};
@@ -350,7 +353,7 @@ std::unique_ptr<std::array<PolynomialInFD<P>, 2 * P::n>> XaittGen()
 template <class P>
 std::unique_ptr<std::array<PolynomialNTT<P>, 2 * P::n>> XaittGenNTT()
 {
-    std::unique_ptr<std::array<PolynomialNTT<P>, 2 *P::n>> xaitt =
+    std::unique_ptr<std::array<PolynomialNTT<P>, 2 * P::n>> xaitt =
         std::make_unique<std::array<PolynomialNTT<P>, 2 * P::n>>();
     for (int i = 0; i < 2 * P::n; i++) {
         std::array<typename P::T, P::n> xai = {};
@@ -366,10 +369,10 @@ std::unique_ptr<std::array<PolynomialNTT<P>, 2 * P::n>> XaittGenNTT()
 
 #if defined(USE_TERNARY) || defined(USE_KEY_BUNDLE)
 alignas(64) static const std::unique_ptr<
-    const std::array<PolynomialInFD<lvl1param>, 2 *lvl1param::n>> xaittlvl1 =
+    const std::array<PolynomialInFD<lvl1param>, 2 * lvl1param::n>> xaittlvl1 =
     XaittGen<lvl1param>();
 alignas(64) static const std::unique_ptr<
-    const std::array<PolynomialInFD<lvl2param>, 2 *lvl2param::n>> xaittlvl2 =
+    const std::array<PolynomialInFD<lvl2param>, 2 * lvl2param::n>> xaittlvl2 =
     XaittGen<lvl2param>();
 #endif
 #ifdef USE_TERNARY
diff --git a/include/params.hpp b/include/params.hpp
index 006b86e..81c954a 100644
--- a/include/params.hpp
+++ b/include/params.hpp
@@ -8,7 +8,8 @@
 
 namespace TFHEpp {
 
-template<class T, size_t N> struct alignas( 64 ) aligned_array : public std::array<T,N> { };
+template <class T, size_t N>
+struct alignas(64) aligned_array : public std::array<T, N> {};
 
 enum class ErrorDistribution { ModularGaussian, CenteredBinomial };
 
diff --git a/include/params/tfhe-rs.hpp b/include/params/tfhe-rs.hpp
index 000af1f..111d3ff 100644
--- a/include/params/tfhe-rs.hpp
+++ b/include/params/tfhe-rs.hpp
@@ -18,8 +18,9 @@ struct lvl0param {
         ErrorDistribution::ModularGaussian;
     static constexpr double α =
         3.2192861177056265e-06;  // fresh noise, 2^{-17.6}
-    using T = uint32_t;         // Torus representation
-    static  constexpr std::make_signed_t<T> μ = 1U << (std::numeric_limits<T>::digits - 3);
+    using T = uint32_t;          // Torus representation
+    static constexpr std::make_signed_t<T> μ =
+        1U << (std::numeric_limits<T>::digits - 3);
     static constexpr uint32_t plain_modulus = 2;
     static constexpr double Δ =
         static_cast<double>(1ULL << std::numeric_limits<T>::digits) /
@@ -37,7 +38,8 @@ struct lvlhalfparam {
         ErrorDistribution::ModularGaussian;
     static const inline double α = std::pow(2.0, -17);  // fresh noise
     using T = uint32_t;                                 // Torus representation
-    static constexpr std::make_signed_t<T> μ = 1U << (std::numeric_limits<T>::digits - 3);
+    static constexpr std::make_signed_t<T> μ =
+        1U << (std::numeric_limits<T>::digits - 3);
     static constexpr uint32_t plain_modulus = 8;
     static constexpr double Δ =
         static_cast<double>(1ULL << std::numeric_limits<T>::digits) /
@@ -59,7 +61,7 @@ struct lvl1param {
         ErrorDistribution::ModularGaussian;
     static const inline double α =
         3.966608917163306e-12;  // fresh noise, 2^{-24.8...}
-    using T = uint64_t;                  // Torus representation
+    using T = uint64_t;         // Torus representation
     static constexpr std::make_signed_t<T> μ = 1ULL << 61;
     static constexpr uint32_t plain_modulus = 2;
     static constexpr double Δ =
diff --git a/include/trgsw.hpp b/include/trgsw.hpp
index b7c0a05..7a85856 100644
--- a/include/trgsw.hpp
+++ b/include/trgsw.hpp
@@ -21,8 +21,8 @@ constexpr typename P::T offsetgen()
 }
 
 template <class P>
-inline void Decomposition(DecomposedPolynomial<P> &decpoly, const Polynomial<P> &poly,
-                   typename P::T randbits = 0)
+inline void Decomposition(DecomposedPolynomial<P> &decpoly,
+                          const Polynomial<P> &poly, typename P::T randbits = 0)
 {
 #ifdef USE_OPTIMAL_DECOMPOSITION
     // https://eprint.iacr.org/2021/1161
diff --git a/include/utils.hpp b/include/utils.hpp
index 2507650..836f9f7 100644
--- a/include/utils.hpp
+++ b/include/utils.hpp
@@ -7,10 +7,10 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include <cstdlib>
 #include <functional>
 #include <limits>
 #include <random>
-#include <cstdlib>
 
 namespace TFHEpp {
 #ifdef USE_RANDEN
@@ -26,17 +26,10 @@ constexpr bool false_v = false;
 
 // https://qiita.com/negi-drums/items/a527c05050781a5af523
 template <typename T>
-concept hasq = requires
-{
-    T::q;
-};
+concept hasq = requires { T::q; };
 
 template <typename T>
-concept hasqbit = requires
-{
-    T::qbit;
-};
-
+concept hasqbit = requires { T::qbit; };
 
 // https://github.com/zhourrr/aligned-memory-allocator/blob/main/aligned_allocator.h
 // A minimal implementation of an allocator for C++ Standard Library, which
@@ -45,50 +38,63 @@ concept hasqbit = requires
 //    A minimal custom allocator is preferred because C++ allocator_traits class
 //    provides default implementation for you. Take a look at Microsoft's
 //    documentation about Allocators and allocator class.
-template <typename T, std::size_t alignment> class AlignedAllocator {
-  public:
+template <typename T, std::size_t alignment>
+class AlignedAllocator {
+public:
     using value_type = T;
 
-  public:
-    // According to Microsoft's documentation, default constructor is not required
-    // by C++ Standard Library.
+public:
+    // According to Microsoft's documentation, default constructor is not
+    // required by C++ Standard Library.
     AlignedAllocator() noexcept {};
 
-    template <typename U> AlignedAllocator(const AlignedAllocator<U, alignment>& other) noexcept {};
+    template <typename U>
+    AlignedAllocator(const AlignedAllocator<U, alignment> &other) noexcept {};
 
     template <typename U>
-    inline bool operator==(const AlignedAllocator<U, alignment>& other) const noexcept {
+    inline bool operator==(
+        const AlignedAllocator<U, alignment> &other) const noexcept
+    {
         return true;
     }
 
     template <typename U>
-    inline bool operator!=(const AlignedAllocator<U, alignment>& other) const noexcept {
+    inline bool operator!=(
+        const AlignedAllocator<U, alignment> &other) const noexcept
+    {
         return false;
     }
 
-    template <typename U> struct rebind {
+    template <typename U>
+    struct rebind {
         using other = AlignedAllocator<U, alignment>;
     };
 
-    // STL containers call this function to allocate uninitialized memory block to
-    // store (no more than n) elements of type T (value_type).
-    inline value_type* allocate(const std::size_t n) const {
+    // STL containers call this function to allocate uninitialized memory block
+    // to store (no more than n) elements of type T (value_type).
+    inline value_type *allocate(const std::size_t n) const
+    {
         auto size = n;
         /*
-          If you wish, for some strange reason, that the size of allocated buffer is
-          also aligned to alignment, uncomment the following statement.
+          If you wish, for some strange reason, that the size of allocated
+          buffer is also aligned to alignment, uncomment the following
+          statement.
 
           Note: this increases the size of underlying memory, but STL containers
-          still treat it as a memory block of size n, i.e., STL containers will not
-          put more than n elements into the returned memory.
+          still treat it as a memory block of size n, i.e., STL containers will
+          not put more than n elements into the returned memory.
         */
         // size = (n + alignment - 1) / alignment * alignment;
-        return static_cast<value_type *>(std::aligned_alloc(alignment, sizeof(T) * size));
+        return static_cast<value_type *>(
+            std::aligned_alloc(alignment, sizeof(T) * size));
     };
 
     // STL containers call this function to free a memory block beginning at a
     // specified position.
-    inline void deallocate(value_type* const ptr, std::size_t n) const noexcept { std::free(ptr); }
+    inline void deallocate(value_type *const ptr, std::size_t n) const noexcept
+    {
+        std::free(ptr);
+    }
 };
 
 // Double to Torus(32bit fixed-point number)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 925951b..b947b97 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -46,7 +46,8 @@ elseif(USE_CONCRETE_FFT)
 else()
   if(USE_MKL)
     target_link_libraries(tfhe++ INTERFACE mklproc)
-    target_include_directories(tfhe++ PUBLIC ${MKLROOT}/include ${PROJECT_SOURCE_DIR}/thirdparties/mkl)
+    target_include_directories(
+      tfhe++ PUBLIC ${MKLROOT}/include ${PROJECT_SOURCE_DIR}/thirdparties/mkl)
   else()
     target_link_libraries(tfhe++ INTERFACE spqlios)
   endif()
diff --git a/test/cereal.cpp b/test/cereal.cpp
index 99fdb0c..8668fc7 100644
--- a/test/cereal.cpp
+++ b/test/cereal.cpp
@@ -24,8 +24,7 @@ int main()
             assert(sk.key.lvl1[i] == ski.key.lvl1[i]);
         for (int i = 0; i < TFHEpp::lvl2param::n; i++)
             assert(sk.key.lvl2[i] == ski.key.lvl2[i]);
-        std::cout << "n"
-                  << ":" << ski.params.lvl0.n << std::endl;
+        std::cout << "n" << ":" << ski.params.lvl0.n << std::endl;
         assert(sk.params == ski.params);
     }
 
diff --git a/test/circuitbootstrapping.cpp b/test/circuitbootstrapping.cpp
index 03f3edb..2f8429c 100644
--- a/test/circuitbootstrapping.cpp
+++ b/test/circuitbootstrapping.cpp
@@ -36,8 +36,10 @@ int main()
         for (int j = 0; j < privksP::targetP::n; j++)
             pmu[i][j] = pa[i][j] ? privksP::targetP::μ : -privksP::targetP::μ;
     for (int i = 0; i < num_test; i++) pones[i] = true;
-    alignas(64) std::vector<TFHEpp::TRLWE<typename privksP::targetP>> ca(num_test);
-    alignas(64) std::vector<TFHEpp::TLWE<typename iksP::domainP>> cones(num_test);
+    alignas(64) std::vector<TFHEpp::TRLWE<typename privksP::targetP>> ca(
+        num_test);
+    alignas(64) std::vector<TFHEpp::TLWE<typename iksP::domainP>> cones(
+        num_test);
     std::vector<TFHEpp::TRGSWFFT<typename privksP::targetP>> bootedTGSW(
         num_test);
 
diff --git a/test/circuitbootstrappingsub.cpp b/test/circuitbootstrappingsub.cpp
index b6f6747..dd8437b 100644
--- a/test/circuitbootstrappingsub.cpp
+++ b/test/circuitbootstrappingsub.cpp
@@ -39,8 +39,10 @@ int main()
     for (int i = 0; i < num_test; i++) pones[i] = true;
     std::vector<TFHEpp::TRLWE<typename privksP::targetP>> ca(num_test);
     std::vector<TFHEpp::TLWE<typename iksP::domainP>> cones(num_test);
-    std::vector<TFHEpp::TRGSWFFT<typename privksP::targetP>,TFHEpp::AlignedAllocator<TFHEpp::TRGSWFFT<typename privksP::targetP>,64>> bootedTGSW(
-        num_test);
+    std::vector<TFHEpp::TRGSWFFT<typename privksP::targetP>,
+                TFHEpp::AlignedAllocator<
+                    TFHEpp::TRGSWFFT<typename privksP::targetP>, 64>>
+        bootedTGSW(num_test);
 
     for (int i = 0; i < num_test; i++)
         ca[i] = TFHEpp::trlweSymEncrypt<typename privksP::targetP>(
diff --git a/test/cmux.cpp b/test/cmux.cpp
index eddcc84..845e004 100644
--- a/test/cmux.cpp
+++ b/test/cmux.cpp
@@ -35,7 +35,9 @@ int main()
     for (int i = 0; i < num_test; i++)
         for (int j = 0; j < lvl1param::n; j++)
             pmu0[i][j] = (p0[i][j] > 0) ? lvl1param::μ : -lvl1param::μ;
-    vector<TRGSWFFT<lvl1param>,TFHEpp::AlignedAllocator<TFHEpp::TRGSWFFT<TFHEpp::lvl1param>,64>> cs(num_test);
+    vector<TRGSWFFT<lvl1param>,
+           TFHEpp::AlignedAllocator<TFHEpp::TRGSWFFT<TFHEpp::lvl1param>, 64>>
+        cs(num_test);
     vector<TRLWE<lvl1param>> c1(num_test);
     vector<TRLWE<lvl1param>> c0(num_test);
     vector<TRLWE<lvl1param>> cres(num_test);
diff --git a/test/cmuxpmbxmo.cpp b/test/cmuxpmbxmo.cpp
index 204d2e7..4052b5e 100644
--- a/test/cmuxpmbxmo.cpp
+++ b/test/cmuxpmbxmo.cpp
@@ -33,7 +33,10 @@ int main()
     for (int i = 0; i < num_test; i++)
         for (int j = 0; j < lvl1param::n; j++)
             pmu1[i][j] = (p1[i][j] > 0) ? lvl1param::μ : -lvl1param::μ;
-    std::vector<TFHEpp::BootstrappingKeyElementFFT<TFHEpp::lvl01param>,TFHEpp::AlignedAllocator<TFHEpp::BootstrappingKeyElementFFT<TFHEpp::lvl01param>,64>> cs(num_test);
+    std::vector<TFHEpp::BootstrappingKeyElementFFT<TFHEpp::lvl01param>,
+                TFHEpp::AlignedAllocator<
+                    TFHEpp::BootstrappingKeyElementFFT<TFHEpp::lvl01param>, 64>>
+        cs(num_test);
     std::vector<TRLWE<lvl1param>> c1(num_test);
     std::vector<TRLWE<lvl1param>> cres(num_test);
 
diff --git a/test/combinedmem.cpp b/test/combinedmem.cpp
index d62557d..cd27c34 100644
--- a/test/combinedmem.cpp
+++ b/test/combinedmem.cpp
@@ -158,10 +158,10 @@ int main()
                 writep[i] = ramp[addressint * words + i] > 0 ? 0 : 1;
 
             std::array<array<TRGSWFFT<lvl1param>, address_bit - 1>, 2>
-                *bootedTGSW =
-                    new (std::align_val_t(64))  array<array<TRGSWFFT<lvl1param>, address_bit - 1>,
-                              2>;  // MSB of address is evaluated by HomMUX, not
-                                   // CMUX.
+                *bootedTGSW = new (std::align_val_t(64))
+                    array<array<TRGSWFFT<lvl1param>, address_bit - 1>,
+                          2>;  // MSB of address is evaluated by HomMUX, not
+                               // CMUX.
             vector<TLWE<lvl1param>> encaddress(address_bit);
             std::vector<TRLWE<lvl1param>> encrom(numromtrlwe);
             std::vector<array<TRLWE<lvl1param>, numramtrlwe>> encram(words);
diff --git a/test/gatebootstrapping.cpp b/test/gatebootstrapping.cpp
index a3a3337..6d07dcc 100644
--- a/test/gatebootstrapping.cpp
+++ b/test/gatebootstrapping.cpp
@@ -22,7 +22,8 @@ int main()
     TFHEpp::EvalKey ek;
     ek.emplacebkfft<bkP>(sk);
     ek.emplaceiksk<iksP>(sk);
-    std::vector<TFHEpp::TLWE<typename iksP::domainP>> tlwe(num_test), bootedtlwe(num_test);
+    std::vector<TFHEpp::TLWE<typename iksP::domainP>> tlwe(num_test),
+        bootedtlwe(num_test);
     std::array<bool, num_test> p;
     for (int i = 0; i < num_test; i++) p[i] = binary(engine) > 0;
     for (int i = 0; i < num_test; i++)
diff --git a/test/invcircuitbootstrapping.cpp b/test/invcircuitbootstrapping.cpp
index 3550301..f618af3 100644
--- a/test/invcircuitbootstrapping.cpp
+++ b/test/invcircuitbootstrapping.cpp
@@ -33,10 +33,16 @@ int main()
         for (int j = 0; j < lvl1param::n; j++)
             pmu[i][j] = pa[i][j] ? lvl1param::μ : -lvl1param::μ;
     for (int i = 0; i < num_test; i++) pzeros[i] = false;
-    vector<TRLWE<lvl1param>,TFHEpp::AlignedAllocator<TFHEpp::TRLWE<TFHEpp::lvl1param>,64>> ca(num_test);
+    vector<TRLWE<lvl1param>,
+           TFHEpp::AlignedAllocator<TFHEpp::TRLWE<TFHEpp::lvl1param>, 64>>
+        ca(num_test);
     vector<TLWE<lvl1param>> czeros(num_test);
-    vector<TRGSWFFT<lvl1param>,TFHEpp::AlignedAllocator<TFHEpp::TRGSWFFT<TFHEpp::lvl1param>,64>> bootedTGSW(num_test);
-    vector<TRGSWFFT<lvl1param>,TFHEpp::AlignedAllocator<TFHEpp::TRGSWFFT<TFHEpp::lvl1param>,64>> invbootedTGSW(num_test);
+    vector<TRGSWFFT<lvl1param>,
+           TFHEpp::AlignedAllocator<TFHEpp::TRGSWFFT<TFHEpp::lvl1param>, 64>>
+        bootedTGSW(num_test);
+    vector<TRGSWFFT<lvl1param>,
+           TFHEpp::AlignedAllocator<TFHEpp::TRGSWFFT<TFHEpp::lvl1param>, 64>>
+        invbootedTGSW(num_test);
 
     for (int i = 0; i < num_test; i++)
         ca[i] = trlweSymEncrypt<lvl1param>(pmu[i], sk->key.lvl1);
diff --git a/test/nested_cmux.cpp b/test/nested_cmux.cpp
index 4699ec2..2829bd0 100644
--- a/test/nested_cmux.cpp
+++ b/test/nested_cmux.cpp
@@ -49,7 +49,9 @@ int main()
 
     SecretKey skey;
 
-    std::vector<TRGSWLvl1FFT,TFHEpp::AlignedAllocator<TFHEpp::TRGSWFFT<TFHEpp::lvl1param>,64>> guard;
+    std::vector<TRGSWLvl1FFT, TFHEpp::AlignedAllocator<
+                                  TFHEpp::TRGSWFFT<TFHEpp::lvl1param>, 64>>
+        guard;
     TFHEpp::Polynomial<TFHEpp::lvl1param> plainpoly = {};
     plainpoly[0] = 1;
     for (size_t i = 0; i < N; i++)
@@ -57,7 +59,7 @@ int main()
             TFHEpp::trgswfftSymEncrypt<Lvl1>(plainpoly, skey.key.lvl1));
 
     alignas(64) TRLWELvl1 c1 = trivial_TRLWELvl1(uint2weight(1)),
-              c0 = trivial_TRLWELvl1(uint2weight(0));
+                          c0 = trivial_TRLWELvl1(uint2weight(0));
     alignas(64) TRLWELvl1 res = c1;
     dump_histgram_of_phase_of_TRLWELvl1(
         std::cout, TFHEpp::trlwePhase<TFHEpp::lvl1param>(res, skey.key.lvl1));
diff --git a/test/nested_cmux_from_cb.cpp b/test/nested_cmux_from_cb.cpp
index 681eaa5..dcaddbe 100644
--- a/test/nested_cmux_from_cb.cpp
+++ b/test/nested_cmux_from_cb.cpp
@@ -53,7 +53,9 @@ int main()
     ekey.emplacebkfft<TFHEpp::lvl02param>(skey);
     ekey.emplaceprivksk4cb<TFHEpp::lvl21param>(skey);
 
-    std::vector<TRGSWLvl1FFT,TFHEpp::AlignedAllocator<TFHEpp::TRGSWFFT<TFHEpp::lvl1param>,64>> guard;
+    std::vector<TRGSWLvl1FFT, TFHEpp::AlignedAllocator<
+                                  TFHEpp::TRGSWFFT<TFHEpp::lvl1param>, 64>>
+        guard;
     for (size_t i = 0; i < N; i++) {
         TFHEpp::TRGSWFFT<Lvl1> trgsw;
         TFHEpp::TLWE<Lvl1> tlwe =
diff --git a/test/polymul.cpp b/test/polymul.cpp
index ff521d2..a567fee 100644
--- a/test/polymul.cpp
+++ b/test/polymul.cpp
@@ -15,10 +15,9 @@ int main()
     uniform_int_distribution<uint32_t> Bgdist(0, lvl1param::Bg);
     uniform_int_distribution<uint32_t> Torus32dist(0, UINT32_MAX);
 
-    #ifdef USE_INTERLEAVED_FORMAT
+#ifdef USE_INTERLEAVED_FORMAT
     std::cout << "USE_INTERLEAVED_FORMAT" << std::endl;
-    #endif
-
+#endif
 
     cout << "Start LVL1 test." << endl;
     for (int test = 0; test < num_test; test++) {
diff --git a/test/ram.cpp b/test/ram.cpp
index e6829e3..e70abd2 100644
--- a/test/ram.cpp
+++ b/test/ram.cpp
@@ -51,12 +51,13 @@ int main()
     wrflag = binary(engine);
     writep = pmemory[addressint] > 0 ? 0 : 1;
 
-    array<array<TRGSWFFT<typename CBprivksP::targetP>, address_bit>,
-          2> *bootedTGSW =
-        new (std::align_val_t(64))  array<array<TRGSWFFT<typename CBprivksP::targetP>, address_bit>, 2>;
+    array<array<TRGSWFFT<typename CBprivksP::targetP>, address_bit>, 2>
+        *bootedTGSW = new (std::align_val_t(64))
+            array<array<TRGSWFFT<typename CBprivksP::targetP>, address_bit>, 2>;
     vector<TLWE<typename CBprivksP::targetP>> encaddress(address_bit);
     array<TRLWE<typename CBprivksP::targetP>, memsize> *encmemory =
-        new (std::align_val_t(64))  array<TRLWE<typename CBprivksP::targetP>, memsize>;
+        new (std::align_val_t(64))
+            array<TRLWE<typename CBprivksP::targetP>, memsize>;
     TLWE<typename CBprivksP::targetP> encreadres;
     TRLWE<typename CBiksP::domainP> encumemory;
     TLWE<typename ksP::domainP> cs;
diff --git a/thirdparties/fftw/fft_processor_fftw.cpp b/thirdparties/fftw/fft_processor_fftw.cpp
index 77bc864..50caee2 100644
--- a/thirdparties/fftw/fft_processor_fftw.cpp
+++ b/thirdparties/fftw/fft_processor_fftw.cpp
@@ -17,8 +17,10 @@ FFT_Processor_FFTW::FFT_Processor_FFTW(const int32_t N)
 {
     inbuf = (fftw_complex *)fftw_malloc(sizeof(fftw_complex) * Ns2);
     outbuf = (fftw_complex *)fftw_malloc(sizeof(fftw_complex) * Ns2);
-    plan_forward = fftw_plan_dft_1d(Ns2, inbuf, outbuf, FFTW_FORWARD, FFTW_MEASURE);
-    plan_backward = fftw_plan_dft_1d(Ns2, inbuf, outbuf, FFTW_BACKWARD, FFTW_MEASURE);
+    plan_forward =
+        fftw_plan_dft_1d(Ns2, inbuf, outbuf, FFTW_FORWARD, FFTW_MEASURE);
+    plan_backward =
+        fftw_plan_dft_1d(Ns2, inbuf, outbuf, FFTW_BACKWARD, FFTW_MEASURE);
 
     for (int i = 0; i < Ns2; i++) {
         double value = (double)i * M_PI / (double)N;
@@ -68,8 +70,8 @@ void FFT_Processor_FFTW::execute_direct_torus32(uint32_t *res, const double *a)
     }
     fftw_execute_dft(plan_backward, inbuf, outbuf);
     for (int i = 0; i < Ns2; i++) {
-        auto res_tmp =
-            std::complex<double>(outbuf[i][0], outbuf[i][1]) * std::conj(twist[i]);
+        auto res_tmp = std::complex<double>(outbuf[i][0], outbuf[i][1]) *
+                       std::conj(twist[i]);
         res[i] = CAST_DOUBLE_TO_UINT32(res_tmp.real());
         res[i + Ns2] = CAST_DOUBLE_TO_UINT32(res_tmp.imag());
     }
@@ -85,8 +87,8 @@ void FFT_Processor_FFTW::execute_direct_torus32_rescale(uint32_t *res,
     }
     fftw_execute_dft(plan_backward, inbuf, outbuf);
     for (int i = 0; i < Ns2; i++) {
-        auto res_tmp =
-            std::complex<double>(outbuf[i][0], outbuf[i][1]) * std::conj(twist[i]);
+        auto res_tmp = std::complex<double>(outbuf[i][0], outbuf[i][1]) *
+                       std::conj(twist[i]);
         res[i] = CAST_DOUBLE_TO_UINT32(res_tmp.real() / (Δ / 4));
         res[i + Ns2] = CAST_DOUBLE_TO_UINT32(res_tmp.imag() / (Δ / 4));
     }
@@ -101,8 +103,8 @@ void FFT_Processor_FFTW::execute_direct_torus64(uint64_t *res, const double *a)
     fftw_execute_dft(plan_backward, inbuf, outbuf);
     double tmp[N];
     for (int i = 0; i < Ns2; i++) {
-        auto res_tmp =
-            std::complex<double>(outbuf[i][0], outbuf[i][1]) * std::conj(twist[i]);
+        auto res_tmp = std::complex<double>(outbuf[i][0], outbuf[i][1]) *
+                       std::conj(twist[i]);
         tmp[i] = res_tmp.real();
         tmp[i + Ns2] = res_tmp.imag();
     }
@@ -121,7 +123,10 @@ void FFT_Processor_FFTW::execute_direct_torus64(uint64_t *res, const double *a)
     }
 }
 
-void FFT_Processor_FFTW::execute_direct_torus64_rescale(uint64_t* res, const double* a, const double Δ) {
+void FFT_Processor_FFTW::execute_direct_torus64_rescale(uint64_t *res,
+                                                        const double *a,
+                                                        const double Δ)
+{
     for (int i = 0; i < Ns2; i++) {
         inbuf[i][0] = a[i] / Ns2;
         inbuf[i][1] = a[Ns2 + i] / Ns2;
@@ -129,12 +134,12 @@ void FFT_Processor_FFTW::execute_direct_torus64_rescale(uint64_t* res, const dou
     fftw_execute_dft(plan_backward, inbuf, outbuf);
     double tmp[N];
     for (int i = 0; i < Ns2; i++) {
-        auto res_tmp =
-            std::complex<double>(outbuf[i][0], outbuf[i][1]) * std::conj(twist[i]);
+        auto res_tmp = std::complex<double>(outbuf[i][0], outbuf[i][1]) *
+                       std::conj(twist[i]);
         tmp[i] = res_tmp.real();
         tmp[i + Ns2] = res_tmp.imag();
     }
-    for (int i=0; i<N; i++) res[i] = uint64_t(std::round(tmp[i]/(Δ/4)));
+    for (int i = 0; i < N; i++) res[i] = uint64_t(std::round(tmp[i] / (Δ / 4)));
 }
 
 FFT_Processor_FFTW::~FFT_Processor_FFTW()
diff --git a/thirdparties/fftw/fft_processor_fftw.h b/thirdparties/fftw/fft_processor_fftw.h
index d767354..5bf19da 100644
--- a/thirdparties/fftw/fft_processor_fftw.h
+++ b/thirdparties/fftw/fft_processor_fftw.h
@@ -19,8 +19,8 @@ class FFT_Processor_FFTW {
     std::vector<std::complex<double>> twist;
     fftw_plan plan_forward;
     fftw_plan plan_backward;
-    fftw_complex * inbuf;
-    fftw_complex * outbuf;
+    fftw_complex *inbuf;
+    fftw_complex *outbuf;
 
 public:
     FFT_Processor_FFTW(const int32_t N);
@@ -38,7 +38,8 @@ class FFT_Processor_FFTW {
 
     void execute_direct_torus64(uint64_t *res, const double *a);
 
-    void execute_direct_torus64_rescale(uint64_t *res, const double *a, const double Δ);
+    void execute_direct_torus64_rescale(uint64_t *res, const double *a,
+                                        const double Δ);
 
     ~FFT_Processor_FFTW();
 };