diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7fa54b5..2e8ca93 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -78,6 +78,10 @@ if(USE_FFTW3)
 elseif(USE_SPQLIOX_AARCH64)
   add_compile_definitions(USE_SPQLIOX_AARCH64)
   add_subdirectory(thirdparties/spqliox_aarch64)
+  # Check if the platform is macOS and the architecture is ARM64
+  if(APPLE AND CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
+    include_directories(/opt/homebrew/include)
+  endif()
 else()
   add_subdirectory(thirdparties/spqlios)
 endif()
diff --git a/include/circuitbootstrapping.hpp b/include/circuitbootstrapping.hpp
index c8f0830..eb1053e 100644
--- a/include/circuitbootstrapping.hpp
+++ b/include/circuitbootstrapping.hpp
@@ -21,16 +21,14 @@ constexpr Polynomial<typename P::domainP> CBtestvector()
     return poly;
 }
 
-template <class iksP, class bkP, class privksP>
+template <class bkP, class privksP>
 void CircuitBootstrapping(TRGSW<typename privksP::targetP> &trgsw,
-                          const TLWE<typename iksP::domainP> &tlwe,
+                          const TLWE<typename bkP::domainP> &tlwe,
                           const EvalKey &ek)
 {
-    TLWE<typename bkP::domainP> tlwelvl0;
-    IdentityKeySwitch<iksP>(tlwelvl0, tlwe, ek.getiksk<iksP>());
     std::array<TLWE<typename bkP::targetP>, privksP::targetP::l> temp;
     GateBootstrappingManyLUT<bkP, privksP::targetP::l>(
-        temp, tlwelvl0, ek.getbkfft<bkP>(), CBtestvector<privksP>());
+        temp, tlwe, ek.getbkfft<bkP>(), CBtestvector<privksP>());
     for (int i = 0; i < privksP::targetP::l; i++) {
         temp[i][privksP::domainP::k * privksP::domainP::n] +=
             1ULL << (numeric_limits<typename privksP::domainP::T>::digits -
@@ -42,26 +40,27 @@ void CircuitBootstrapping(TRGSW<typename privksP::targetP> &trgsw,
     }
 }
 
-// template <class iksP, class bkP, class privksP>
-// void AnnihilateCircuitBootstrapping(TRGSW<typename privksP::targetP> &trgsw,
-//                           const TLWE<typename iksP::domainP> &tlwe,
-//                           const EvalKey &ek)
-// {
-//     TLWE<typename bkP::domainP> tlwelvl0;
-//     IdentityKeySwitch<iksP>(tlwelvl0, tlwe, ek.getiksk<iksP>());
-//     TRLWE<typename bkP::targetP>> trlwe;
-//     BlindRotate<bkP, privksP::targetP::l>(
-//         trlwe, tlwelvl0, ek.getbkfft<bkP>(), CBtestvector<privksP>());
-//     for (int i = 0; i < privksP::targetP::l; i++)
-//         temp[i][privksP::domainP::k * privksP::domainP::n] +=
-//             1ULL << (numeric_limits<typename privksP::domainP::T>::digits -
-//                      (i + 1) * privksP::targetP::Bgbit - 1);
-//     for (int i = 0; i < privksP::targetP::l; i++)
-//         for (int k = 0; k < privksP::targetP::k + 1; k++)
-//             PrivKeySwitch<privksP>(
-//                 trgsw[i + k * privksP::targetP::l], temp[i],
-//                 ek.getprivksk<privksP>("privksk4cb_" + std::to_string(k)));
-// }
+template <class iksP, class bkP, class privksP>
+void CircuitBootstrapping(TRGSW<typename privksP::targetP> &trgsw,
+                          const TLWE<typename iksP::domainP> &tlwe,
+                          const EvalKey &ek)
+{
+    TLWE<typename bkP::domainP> tlwelvl0;
+    IdentityKeySwitch<iksP>(tlwelvl0, tlwe, ek.getiksk<iksP>());
+    CircuitBootstrapping<bkP, privksP>(trgsw, tlwelvl0, ek);
+}
+
+template <class brP, class privksP>
+void CircuitBootstrappingFFT(TRGSWFFT<typename privksP::targetP> &trgswfft,
+                             const TLWE<typename brP::domainP> &tlwe,
+                             const EvalKey &ek)
+{
+    TRGSW<typename privksP::targetP> trgsw;
+    CircuitBootstrapping<brP, privksP>(trgsw, tlwe, ek);
+    for (int i = 0; i < (privksP::targetP::k + 1) * privksP::targetP::l; i++)
+        for (int j = 0; j < privksP::targetP::k + 1; j++)
+            TwistIFFT<typename privksP::targetP>(trgswfft[i][j], trgsw[i][j]);
+}
 
 template <class iksP, class bkP, class privksP>
 void CircuitBootstrappingFFT(TRGSWFFT<typename privksP::targetP> &trgswfft,
@@ -113,6 +112,18 @@ void CircuitBootstrappingSubFFT(TRGSWFFT<typename privksP::targetP> &trgswfft,
             TwistIFFT<typename privksP::targetP>(trgswfft[i][j], trgsw[i][j]);
 }
 
+template <class brP, class privksP>
+void CircuitBootstrappingFFTInv(
+    TRGSWFFT<typename privksP::targetP> &invtrgswfft,
+    const TLWE<typename brP::domainP> &tlwe, const EvalKey &ek)
+{
+    TLWE<typename brP::domainP> invtlwe;
+    // HomNot
+    for (int i = 0; i <= brP::domainP::k * brP::domainP::n; i++)
+        invtlwe[i] = -tlwe[i];
+    CircuitBootstrappingFFT<brP, privksP>(invtrgswfft, invtlwe, ek);
+}
+
 template <class iksP, class bkP, class privksP>
 void CircuitBootstrappingFFTInv(
     TRGSWFFT<typename privksP::targetP> &invtrgswfft,
@@ -120,10 +131,37 @@ void CircuitBootstrappingFFTInv(
 {
     TLWE<typename iksP::domainP> invtlwe;
     // HomNot
-    for (int i = 0; i <= iksP::domainP::n; i++) invtlwe[i] = -tlwe[i];
+    for (int i = 0; i <= iksP::domainP::k * iksP::domainP::n; i++)
+        invtlwe[i] = -tlwe[i];
     CircuitBootstrappingFFT<iksP, bkP, privksP>(invtrgswfft, invtlwe, ek);
 }
 
+template <class brP, class privksP>
+void CircuitBootstrappingFFTwithInv(
+    TRGSWFFT<typename privksP::targetP> &trgswfft,
+    TRGSWFFT<typename privksP::targetP> &invtrgswfft,
+    const TLWE<typename brP::domainP> &tlwe, const EvalKey &ek)
+{
+    constexpr array<typename privksP::targetP::T, privksP::targetP::l> h =
+        hgen<typename privksP::targetP>();
+
+    TRGSW<typename privksP::targetP> trgsw;
+    CircuitBootstrapping<brP, privksP>(trgsw, tlwe, ek);
+    for (int i = 0; i < (privksP::targetP::k + 1) * privksP::targetP::l; i++)
+        for (int j = 0; j < privksP::targetP::k + 1; j++) {
+            TwistIFFT<typename privksP::targetP>(trgswfft[i][j], trgsw[i][j]);
+            for (int k = 0; k < privksP::targetP::n; k++) trgsw[i][j][k] *= -1;
+        }
+    for (int i = 0; i < privksP::targetP::l; i++) {
+        trgsw[i][0][0] += h[i];
+        trgsw[i + privksP::targetP::l][1][0] += h[i];
+    }
+    for (int i = 0; i < (privksP::targetP::k + 1) * privksP::targetP::l; i++)
+        for (int j = 0; j < privksP::targetP::k + 1; j++)
+            TwistIFFT<typename privksP::targetP>(invtrgswfft[i][j],
+                                                 trgsw[i][j]);
+}
+
 template <class iksP, class bkP, class privksP>
 void CircuitBootstrappingFFTwithInv(
     TRGSWFFT<typename privksP::targetP> &trgswfft,
diff --git a/include/cloudkey.hpp b/include/cloudkey.hpp
index 0a69865..f400e7d 100644
--- a/include/cloudkey.hpp
+++ b/include/cloudkey.hpp
@@ -332,28 +332,28 @@ relinKeyFFT<P> relinKeyFFTgen(const Key<P>& key)
 
 struct EvalKey {
     lweParams params;
-    std::unique_ptr<BootstrappingKey<lvl01param>> bklvl01;
-    std::unique_ptr<BootstrappingKey<lvl02param>> bklvl02;
-    std::unique_ptr<BootstrappingKeyFFT<lvl01param>> bkfftlvl01;
-    std::unique_ptr<BootstrappingKeyFFT<lvl02param>> bkfftlvl02;
-    std::unique_ptr<BootstrappingKeyNTT<lvl01param>> bknttlvl01;
-    std::unique_ptr<BootstrappingKeyNTT<lvl02param>> bknttlvl02;
-    std::unique_ptr<KeySwitchingKey<lvl10param>> iksklvl10;
-    std::unique_ptr<KeySwitchingKey<lvl20param>> iksklvl20;
-    std::unique_ptr<KeySwitchingKey<lvl21param>> iksklvl21;
-    std::unique_ptr<KeySwitchingKey<lvl22param>> iksklvl22;
-    std::unique_ptr<SubsetKeySwitchingKey<lvl21param>> subiksklvl21;
+    std::shared_ptr<BootstrappingKey<lvl01param>> bklvl01;
+    std::shared_ptr<BootstrappingKey<lvl02param>> bklvl02;
+    std::shared_ptr<BootstrappingKeyFFT<lvl01param>> bkfftlvl01;
+    std::shared_ptr<BootstrappingKeyFFT<lvl02param>> bkfftlvl02;
+    std::shared_ptr<BootstrappingKeyNTT<lvl01param>> bknttlvl01;
+    std::shared_ptr<BootstrappingKeyNTT<lvl02param>> bknttlvl02;
+    std::shared_ptr<KeySwitchingKey<lvl10param>> iksklvl10;
+    std::shared_ptr<KeySwitchingKey<lvl20param>> iksklvl20;
+    std::shared_ptr<KeySwitchingKey<lvl21param>> iksklvl21;
+    std::shared_ptr<KeySwitchingKey<lvl22param>> iksklvl22;
+    std::shared_ptr<SubsetKeySwitchingKey<lvl21param>> subiksklvl21;
     std::unordered_map<std::string,
-                       std::unique_ptr<PrivateKeySwitchingKey<lvl11param>>>
+                       std::shared_ptr<PrivateKeySwitchingKey<lvl11param>>>
         privksklvl11;
     std::unordered_map<std::string,
-                       std::unique_ptr<PrivateKeySwitchingKey<lvl21param>>>
+                       std::shared_ptr<PrivateKeySwitchingKey<lvl21param>>>
         privksklvl21;
     std::unordered_map<std::string,
-                       std::unique_ptr<PrivateKeySwitchingKey<lvl22param>>>
+                       std::shared_ptr<PrivateKeySwitchingKey<lvl22param>>>
         privksklvl22;
     std::unordered_map<
-        std::string, std::unique_ptr<SubsetPrivateKeySwitchingKey<lvl21param>>>
+        std::string, std::shared_ptr<SubsetPrivateKeySwitchingKey<lvl21param>>>
         subprivksklvl21;
 
     EvalKey(SecretKey sk) { params = sk.params; }
diff --git a/include/gate.hpp b/include/gate.hpp
index c49eaa2..decf02b 100644
--- a/include/gate.hpp
+++ b/include/gate.hpp
@@ -6,7 +6,7 @@
 
 namespace TFHEpp {
 template <class brP, typename brP::targetP::T μ, class iksP, int casign,
-          int cbsign, typename brP::targetP::T offset>
+          int cbsign, std::make_signed_t<typename brP::domainP::T> offset>
 inline void HomGate(TLWE<typename iksP::targetP> &res,
                     const TLWE<typename brP::domainP> &ca,
                     const TLWE<typename brP::domainP> &cb, const EvalKey &ek)
@@ -17,7 +17,7 @@ inline void HomGate(TLWE<typename iksP::targetP> &res,
     GateBootstrapping<brP, μ, iksP>(res, res, ek);
 }
 template <class iksP, class brP, typename brP::targetP::T μ, int casign,
-          int cbsign, typename brP::targetP::T offset>
+          int cbsign, typename iksP::domainP::T offset>
 inline void HomGate(TLWE<typename brP::targetP> &res,
                     const TLWE<typename iksP::domainP> &ca,
                     const TLWE<typename iksP::domainP> &cb, const EvalKey &ek)
@@ -291,32 +291,60 @@ void HomMUXwoIKSandSE(TRLWE<typename bkP::targetP> &res,
     };
     res[1][0] += bkP::targetP::μ;
 }
-template <class iksP, class bkP>
-void HomMUXwoSE(TRLWE<typename bkP::targetP> &res,
+
+template <class brP, typename brP::targetP::T μ = brP::targetP::μ>
+void HomMUXwoSE(TRLWE<typename brP::targetP> &res,
+                const TLWE<typename brP::domainP> &cs,
+                const TLWE<typename brP::domainP> &c1,
+                const TLWE<typename brP::domainP> &c0, const EvalKey &ek)
+{
+    TLWE<typename brP::domainP> and1, and0;
+    for (int i = 0; i <= brP::domainP::k * brP::domainP::n; i++)
+        and1[i] = cs[i] + c1[i];
+    for (int i = 0; i <= brP::domainP::k * brP::domainP::n; i++)
+        and0[i] = -cs[i] + c0[i];
+    and1[brP::domainP::k * brP::domainP::n] -= brP::domainP::μ;
+    and0[brP::domainP::k * brP::domainP::n] -= brP::domainP::μ;
+    TRLWE<typename brP::targetP> and0trlwe;
+    BlindRotate<brP>(res, and1, ek.getbkfft<brP>(),
+                     μpolygen<typename brP::targetP, brP::targetP::μ>());
+    BlindRotate<brP>(and0trlwe, and0, ek.getbkfft<brP>(),
+                     μpolygen<typename brP::targetP, brP::targetP::μ>());
+
+    for (int i = 0; i < brP::targetP::k * brP::targetP::n; i++) {
+        res[0][i] += and0trlwe[0][i];
+        res[1][i] += and0trlwe[1][i];
+    };
+    res[1][0] += brP::targetP::μ;
+}
+
+template <class iksP, class brP, typename brP::targetP::T μ = brP::targetP::μ>
+void HomMUXwoSE(TRLWE<typename brP::targetP> &res,
                 const TLWE<typename iksP::domainP> &cs,
                 const TLWE<typename iksP::domainP> &c1,
                 const TLWE<typename iksP::domainP> &c0, const EvalKey &ek)
 {
-    TLWE<typename iksP::domainP> temp1;
-    TLWE<typename iksP::domainP> temp0;
-    for (int i = 0; i <= iksP::domainP::n; i++) temp1[i] = cs[i] + c1[i];
-    for (int i = 0; i <= iksP::domainP::n; i++) temp0[i] = -cs[i] + c0[i];
-    temp1[iksP::domainP::n] -= iksP::domainP::μ;
-    temp0[iksP::domainP::n] -= iksP::domainP::μ;
+    TLWE<typename iksP::domainP> temp1, temp0;
+    for (int i = 0; i <= iksP::domainP::k * iksP::domainP::n; i++)
+        temp1[i] = cs[i] + c1[i];
+    for (int i = 0; i <= iksP::domainP::k * iksP::domainP::n; i++)
+        temp0[i] = -cs[i] + c0[i];
+    temp1[iksP::domainP::k * iksP::domainP::n] -= iksP::domainP::μ;
+    temp0[iksP::domainP::k * iksP::domainP::n] -= iksP::domainP::μ;
     TLWE<typename iksP::targetP> and1, and0;
     IdentityKeySwitch<iksP>(and1, temp1, ek.getiksk<iksP>());
     IdentityKeySwitch<iksP>(and0, temp0, ek.getiksk<iksP>());
-    TRLWE<typename bkP::targetP> and0trlwe;
-    BlindRotate<bkP>(res, and1, ek.getbkfft<bkP>(),
-                     μpolygen<typename bkP::targetP, bkP::targetP::μ>());
-    BlindRotate<bkP>(and0trlwe, and0, ek.getbkfft<bkP>(),
-                     μpolygen<typename bkP::targetP, bkP::targetP::μ>());
+    TRLWE<typename brP::targetP> and0trlwe;
+    BlindRotate<brP>(res, and1, ek.getbkfft<brP>(),
+                     μpolygen<typename brP::targetP, brP::targetP::μ>());
+    BlindRotate<brP>(and0trlwe, and0, ek.getbkfft<brP>(),
+                     μpolygen<typename brP::targetP, brP::targetP::μ>());
 
-    for (int i = 0; i < bkP::targetP::n; i++) {
+    for (int i = 0; i < brP::targetP::k * brP::targetP::n; i++) {
         res[0][i] += and0trlwe[0][i];
         res[1][i] += and0trlwe[1][i];
     };
-    res[1][0] += bkP::targetP::μ;
+    res[1][0] += brP::targetP::μ;
 }
 
 void ExtractSwitchAndHomMUX(TRLWE<lvl1param> &res, const TRLWE<lvl1param> &csr,
diff --git a/include/nussbaumer.hpp b/include/nussbaumer.hpp
new file mode 100644
index 0000000..897d047
--- /dev/null
+++ b/include/nussbaumer.hpp
@@ -0,0 +1,130 @@
+#pragma once
+#include <span>
+
+namespace Nussbaumer {
+
+template <typename T, uint rbit>
+inline void PolynomialMulByXai(const std::span<T, 1ull << rbit> res,
+                               const size_t a)
+{
+    if (a == 0)
+        return;
+    else {
+        constexpr size_t r = 1ull << rbit;
+        std::array<T, r> temp;
+        std::copy(res.begin(), res.end(), temp.begin());
+        if (a < r) {
+            for (int i = 0; i < a; i++) res[i] = -temp[i - a + r];
+            for (int i = a; i < r; i++) res[i] = temp[i - a];
+        }
+        else {
+            const size_t aa = a - r;
+            for (int i = 0; i < aa; i++) res[i] = temp[i - aa + r];
+            for (int i = aa; i < r; i++) res[i] = -temp[i - aa];
+        }
+    }
+}
+
+template <typename T, uint mbit, uint rbit>
+void NussbaumerButterfly(const std::span<T, (1u << (rbit + mbit))> res)
+{
+    constexpr size_t m = 1ull << mbit;
+    constexpr size_t r = 1ull << rbit;
+    for (int i = 0; i < m / 2; i++)
+        for (int j = 0; j < r; j++) {
+            const T temp = res[i * r + j];
+            res[i * r + j] += res[(i + m / 2) * r + j];
+            res[(i + m / 2) * r + j] = temp - res[(i + m / 2) * r + j];
+        }
+    if constexpr (mbit != 1) {
+        constexpr size_t stride = 1ull << (rbit - mbit);
+        for (int i = 1; i < m / 2; i++)
+            PolynomialMulByXai<T, rbit>(
+                static_cast<std::span<T, r>>(res.subspan((i + m / 2) * r, r)),
+                i * stride);
+        NussbaumerButterfly<T, mbit - 1, rbit>(
+            res.template subspan<0, m * r / 2>());
+        NussbaumerButterfly<T, mbit - 1, rbit>(
+            res.template subspan<m * r / 2, m * r / 2>());
+    }
+}
+
+template <typename T, uint Nbit>
+void NussbaumerTransform(std::span<T, (1ull << Nbit)> res)
+{
+    if constexpr (Nbit == 1) {
+        const T temp = res[0];
+        res[0] += res[1];
+        res[1] = temp - res[1];
+        return;
+    }
+    else {
+        // initialize
+        constexpr uint mbit = Nbit / 2;
+        constexpr size_t m = 1ull << mbit;
+        constexpr uint rbit = Nbit - mbit;
+        constexpr size_t r = 1ull << rbit;
+        std::array<T, (1ull << Nbit)> temp;
+        std::copy(res.begin(), res.end(), temp.begin());
+        // reorder
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < r; j++) res[i * r + j] = temp[m * j + i];
+        }
+        NussbaumerButterfly<T, mbit, rbit>(res);
+        for (int i = 0; i < m; i++)
+            NussbaumerTransform<T, rbit>(
+                static_cast<std::span<T, r>>(res.subspan(i * r, r)));
+    }
+}
+
+template <typename T, uint mbit, uint rbit>
+void InverseNussbaumerButterfly(const std::span<T, (1u << (rbit + mbit))> res)
+{
+    constexpr size_t m = 1ull << mbit;
+    constexpr size_t r = 1ull << rbit;
+    if constexpr (mbit != 1) {
+        constexpr size_t stride = 1ull << (rbit - mbit);
+        InverseNussbaumerButterfly<T, mbit - 1, rbit>(
+            res.template subspan<0, m * r / 2>());
+        InverseNussbaumerButterfly<T, mbit - 1, rbit>(
+            res.template subspan<m * r / 2, m * r / 2>());
+        for (int i = 1; i < m / 2; i++)
+            PolynomialMulByXai<T, rbit>(
+                static_cast<std::span<T, r>>(res.subspan((i + m / 2) * r, r)),
+                2 * r - i * stride);
+    }
+    for (int i = 0; i < m / 2; i++)
+        for (int j = 0; j < r; j++) {
+            const T temp = res[i * r + j];
+            res[i * r + j] += res[(i + m / 2) * r + j];
+            res[(i + m / 2) * r + j] = temp - res[(i + m / 2) * r + j];
+        }
+}
+
+template <typename T, uint Nbit>
+void InverseNussbaumerTransform(std::span<T, (1ull << Nbit)> res)
+{
+    if constexpr (Nbit == 1) {
+        const T temp = res[0];
+        res[0] += res[1];
+        res[1] = temp - res[1];
+        return;
+    }
+    else {
+        // initialize
+        constexpr uint mbit = Nbit / 2;
+        constexpr size_t m = 1ull << mbit;
+        constexpr uint rbit = Nbit - mbit;
+        constexpr size_t r = 1ull << rbit;
+        for (int i = 0; i < m; i++)
+            InverseNussbaumerTransform<T, rbit>(
+                static_cast<std::span<T, r>>(res.subspan(i * r, r)));
+        InverseNussbaumerButterfly<T, mbit, rbit>(res);
+        std::array<T, (1ull << Nbit)> temp;
+        std::copy(res.begin(), res.end(), temp.begin());
+        // reorder
+        for (int i = 0; i < m; i++)
+            for (int j = 0; j < r; j++) res[m * j + i] = temp[i * r + j];
+    }
+}
+}  // namespace Nussbaumer
\ No newline at end of file
diff --git a/include/params/128bit.hpp b/include/params/128bit.hpp
index 1d8075c..dfd84e5 100644
--- a/include/params/128bit.hpp
+++ b/include/params/128bit.hpp
@@ -13,7 +13,7 @@ struct lvl0param {
     static constexpr ErrorDistribution errordist =
         ErrorDistribution::ModularGaussian;
     static const inline double α = 0.000'092'511'997'467'675'6;  // fresh noise
-    using T = uint32_t;  // Torus representation
+    using T = uint16_t;  // Torus representation
     static constexpr T μ = 1U << (std::numeric_limits<T>::digits - 3);
     static constexpr uint32_t plain_modulus = 8;
     static constexpr double Δ =
@@ -39,7 +39,8 @@ struct lvl1param {
     static constexpr T μ = 1U << 29;
     static constexpr uint32_t plain_modulus = 8;
     static constexpr double Δ =
-        static_cast<double>(1ULL << std::numeric_limits<T>::digits) / plain_modulus;
+        static_cast<double>(1ULL << std::numeric_limits<T>::digits) /
+        plain_modulus;
 };
 
 struct lvl2param {
diff --git a/include/params/concrete.hpp b/include/params/concrete.hpp
index b3113da..86704dc 100644
--- a/include/params/concrete.hpp
+++ b/include/params/concrete.hpp
@@ -18,7 +18,7 @@ struct lvl0param {
         ErrorDistribution::ModularGaussian;
     static constexpr inline double α =
         0.000'092'511'997'467'675'6;  // fresh noise, 2^{-13.4}
-    using T = uint32_t;               // Torus representation
+    using T = uint16_t;               // Torus representation
     static constexpr T μ = 1U << (std::numeric_limits<T>::digits - 3);
     static constexpr uint32_t plain_modulus = 8;
     static constexpr double Δ =
diff --git a/include/tlwe.hpp b/include/tlwe.hpp
index ce858a8..ddd12af 100644
--- a/include/tlwe.hpp
+++ b/include/tlwe.hpp
@@ -103,6 +103,7 @@ std::vector<TLWE<P>> bootsSymEncrypt(const std::vector<uint8_t> &p,
                                      const Key<P> &key)
 {
     vector<TLWE<P>> c(p.size());
+    #pragma omp parallel for
     for (int i = 0; i < p.size(); i++)
         c[i] = tlweSymEncrypt<P>(p[i] ? P::μ : -P::μ, key);
     return c;
@@ -120,6 +121,7 @@ std::vector<uint8_t> bootsSymDecrypt(const std::vector<TLWE<P>> &c,
                                      const Key<P> &key)
 {
     vector<uint8_t> p(c.size());
+    #pragma omp parallel for
     for (int i = 0; i < c.size(); i++) p[i] = tlweSymDecrypt<P>(c[i], key);
     return p;
 }
diff --git a/test/gate.cpp b/test/gate.cpp
index 3e2f123..8478b3e 100644
--- a/test/gate.cpp
+++ b/test/gate.cpp
@@ -144,39 +144,77 @@ void RunTest()
     vector<TLWE<P>> cres(kNumTests);
     vector<TLWE<P>> c(3 * kNumTests);
 
-    Test<P>("NOT", TFHEpp::HomNOT<P>, NotChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("COPY", TFHEpp::HomCOPY<P>, CopyChegk, p, cres, c, kNumTests, *sk,
-            ek);
-    Test<P>("NAND", TFHEpp::HomNAND<lvl10param, lvl01param, lvl1param::μ>,
-            NandChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("OR", TFHEpp::HomOR<lvl10param, lvl01param, lvl1param::μ>, OrChegk,
-            p, cres, c, kNumTests, *sk, ek);
-    Test<P>("ORYN", TFHEpp::HomORYN<lvl10param, lvl01param, lvl1param::μ>,
-            OrYNChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("ORNY", TFHEpp::HomORNY<lvl10param, lvl01param, lvl1param::μ>,
-            OrNYChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("AND", TFHEpp::HomAND<lvl10param, lvl01param, lvl1param::μ>,
-            AndChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("ANDYN", TFHEpp::HomANDYN<lvl10param, lvl01param, lvl1param::μ>,
-            AndYNChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("ANDNY", TFHEpp::HomANDNY<lvl10param, lvl01param, lvl1param::μ>,
-            AndNYChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("XOR", TFHEpp::HomXOR<lvl10param, lvl01param, lvl1param::μ>,
-            XorChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("XNOR", TFHEpp::HomXNOR<lvl10param, lvl01param, lvl1param::μ>,
-            XnorChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("MUX", TFHEpp::HomMUX<P>, MuxChegk, p, cres, c, kNumTests, *sk, ek);
-    Test<P>("NMUX", TFHEpp::HomNMUX<P>, NMuxChegk, p, cres, c, kNumTests, *sk,
-            ek);
-    Test<P>("ConstantZero", TFHEpp::HomCONSTANTZERO<P>, ConstantZeroChegk, p,
-            cres, c, kNumTests, *sk, ek);
-    Test<P>("ConstantOne", TFHEpp::HomCONSTANTONE<P>, ConstantOneChegk, p, cres,
-            c, kNumTests, *sk, ek);
+    if constexpr (std::is_same_v<P, lvl0param>) {
+        cout << "lvl0param" << endl;
+        Test<P>("NOT", TFHEpp::HomNOT<P>, NotChegk, p, cres, c, kNumTests, *sk,
+                ek);
+        Test<P>("COPY", TFHEpp::HomCOPY<P>, CopyChegk, p, cres, c, kNumTests,
+                *sk, ek);
+        Test<P>("NAND", TFHEpp::HomNAND<lvl01param, lvl1param::μ, lvl10param>,
+                NandChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("OR", TFHEpp::HomOR<lvl01param, lvl1param::μ, lvl10param>,
+                OrChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ORYN", TFHEpp::HomORYN<lvl01param, lvl1param::μ, lvl10param>,
+                OrYNChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ORNY", TFHEpp::HomORNY<lvl01param, lvl1param::μ, lvl10param>,
+                OrNYChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("AND", TFHEpp::HomAND<lvl01param, lvl1param::μ, lvl10param>,
+                AndChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ANDYN", TFHEpp::HomANDYN<lvl01param, lvl1param::μ, lvl10param>,
+                AndYNChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ANDNY", TFHEpp::HomANDNY<lvl01param, lvl1param::μ, lvl10param>,
+                AndNYChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("XOR", TFHEpp::HomXOR<lvl01param, lvl1param::μ, lvl10param>,
+                XorChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("XNOR", TFHEpp::HomXNOR<lvl01param, lvl1param::μ, lvl10param>,
+                XnorChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("MUX", TFHEpp::HomMUX<P>, MuxChegk, p, cres, c, kNumTests, *sk,
+                ek);
+        Test<P>("NMUX", TFHEpp::HomNMUX<P>, NMuxChegk, p, cres, c, kNumTests,
+                *sk, ek);
+        Test<P>("ConstantZero", TFHEpp::HomCONSTANTZERO<P>, ConstantZeroChegk,
+                p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ConstantOne", TFHEpp::HomCONSTANTONE<P>, ConstantOneChegk, p,
+                cres, c, kNumTests, *sk, ek);
+    }
+    else if constexpr (std::is_same_v<P, lvl1param>) {
+        cout << "lvl1param" << endl;
+        Test<P>("NOT", TFHEpp::HomNOT<P>, NotChegk, p, cres, c, kNumTests, *sk,
+                ek);
+        Test<P>("COPY", TFHEpp::HomCOPY<P>, CopyChegk, p, cres, c, kNumTests,
+                *sk, ek);
+        Test<P>("NAND", TFHEpp::HomNAND<lvl10param, lvl01param, lvl1param::μ>,
+                NandChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("OR", TFHEpp::HomOR<lvl10param, lvl01param, lvl1param::μ>,
+                OrChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ORYN", TFHEpp::HomORYN<lvl10param, lvl01param, lvl1param::μ>,
+                OrYNChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ORNY", TFHEpp::HomORNY<lvl10param, lvl01param, lvl1param::μ>,
+                OrNYChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("AND", TFHEpp::HomAND<lvl10param, lvl01param, lvl1param::μ>,
+                AndChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ANDYN", TFHEpp::HomANDYN<lvl10param, lvl01param, lvl1param::μ>,
+                AndYNChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ANDNY", TFHEpp::HomANDNY<lvl10param, lvl01param, lvl1param::μ>,
+                AndNYChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("XOR", TFHEpp::HomXOR<lvl10param, lvl01param, lvl1param::μ>,
+                XorChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("XNOR", TFHEpp::HomXNOR<lvl10param, lvl01param, lvl1param::μ>,
+                XnorChegk, p, cres, c, kNumTests, *sk, ek);
+        Test<P>("MUX", TFHEpp::HomMUX<P>, MuxChegk, p, cres, c, kNumTests, *sk,
+                ek);
+        Test<P>("NMUX", TFHEpp::HomNMUX<P>, NMuxChegk, p, cres, c, kNumTests,
+                *sk, ek);
+        Test<P>("ConstantZero", TFHEpp::HomCONSTANTZERO<P>, ConstantZeroChegk,
+                p, cres, c, kNumTests, *sk, ek);
+        Test<P>("ConstantOne", TFHEpp::HomCONSTANTONE<P>, ConstantOneChegk, p,
+                cres, c, kNumTests, *sk, ek);
+    }
 }
 
 int main()
 {
     RunTest<lvl1param>();
-    // RunTest<lvl0param>();
+    RunTest<lvl0param>();
     return 0;
 }
\ No newline at end of file
diff --git a/test/nussbaumer.cpp b/test/nussbaumer.cpp
new file mode 100644
index 0000000..2286059
--- /dev/null
+++ b/test/nussbaumer.cpp
@@ -0,0 +1,73 @@
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <nussbaumer.hpp>
+#include <random>
+#include <tfhe++.hpp>
+
+int main()
+{
+    constexpr uint32_t num_test = 1000;
+    std::random_device seed_gen;
+    std::default_random_engine engine(seed_gen());
+    std::uniform_int_distribution<uint32_t> Bgdist(0, TFHEpp::lvl1param::Bg);
+    std::uniform_int_distribution<uint32_t> Torus32dist(0, UINT32_MAX);
+
+    // std::cout << "Start LVL1 test." << std::endl;
+    for (int test = 0; test < num_test; test++) {
+        using T = uint64_t;
+        std::array<T, TFHEpp::lvl1param::n> a, res;
+        for (T &i : a) i = Torus32dist(engine);
+        res = a;
+        Nussbaumer::NussbaumerTransform<T, TFHEpp::lvl1param::nbit>(
+            std::span{res});
+        Nussbaumer::InverseNussbaumerTransform<T, TFHEpp::lvl1param::nbit>(
+            std::span{res});
+        for (int i = 0; i < TFHEpp::lvl1param::n; i++)
+            assert(abs(static_cast<int32_t>(
+                           a[i] - res[i] / TFHEpp::lvl1param::n) <= 1));
+    }
+    std::cout << "Id Passed" << std::endl;
+
+    // for (int test = 0; test < num_test; test++) {
+    //     array<typename TFHEpp::lvl1param::T, lvl1param::n> a;
+    //     for (int i = 0; i < lvl1param::n; i++)
+    //         a[i] = Bgdist(engine) - lvl1param::Bg / 2;
+    //     for (typename TFHEpp::lvl1param::T &i : a)
+    //         i = Bgdist(engine) - lvl1param::Bg / 2;
+    //     array<typename TFHEpp::lvl1param::T, lvl1param::n> b;
+    //     for (typename TFHEpp::lvl1param::T &i : b) i = Torus32dist(engine);
+
+    //     Polynomial<lvl1param> polymul;
+    //     TFHEpp::PolyMul<lvl1param>(polymul, a, b);
+    //     Polynomial<lvl1param> naieve = {};
+    //     for (int i = 0; i < lvl1param::n; i++) {
+    //         for (int j = 0; j <= i; j++)
+    //             naieve[i] += static_cast<int32_t>(a[j]) * b[i - j];
+    //         for (int j = i + 1; j < lvl1param::n; j++)
+    //             naieve[i] -=
+    //                 static_cast<int32_t>(a[j]) * b[lvl1param::n + i - j];
+    //     }
+    //     for (int i = 0; i < lvl1param::n; i++)
+    //         assert(abs(static_cast<int32_t>(naieve[i] - polymul[i])) <= 1);
+    // }
+    // cout << "PolyMul Passed" << endl;
+
+    // uniform_int_distribution<uint64_t> Bgbardist(0, lvl2param::Bg);
+    // uniform_int_distribution<uint64_t> Torus64dist(0, UINT64_MAX);
+
+    // cout << "Start LVL2 test." << endl;
+    // for (int test = 0; test < num_test; test++) {
+    //     Polynomial<lvl2param> a;
+    //     for (uint64_t &i : a) i = Torus64dist(engine);
+    //     PolynomialInFD<lvl2param> resfft;
+    //     TFHEpp::TwistIFFT<lvl2param>(resfft, a);
+    //     Polynomial<lvl2param> res;
+    //     TFHEpp::TwistFFT<lvl2param>(res, resfft);
+    //     for (int i = 0; i < lvl2param::n; i++)
+    //         assert(abs(static_cast<int64_t>(a[i] - res[i])) <= (1 << 14));
+    // }
+    // cout << "FFT Passed" << endl;
+
+    return 0;
+}
\ No newline at end of file
diff --git a/thirdparties/cereal b/thirdparties/cereal
index d1fcec8..ddd4672 160000
--- a/thirdparties/cereal
+++ b/thirdparties/cereal
@@ -1 +1 @@
-Subproject commit d1fcec807b372f04e4c1041b3058e11c12853e6e
+Subproject commit ddd467244713ea4fe63733628992efcdd6a9187d
diff --git a/thirdparties/spqliox_aarch64/CMakeLists.txt b/thirdparties/spqliox_aarch64/CMakeLists.txt
index 0f12a99..ea37a2d 100644
--- a/thirdparties/spqliox_aarch64/CMakeLists.txt
+++ b/thirdparties/spqliox_aarch64/CMakeLists.txt
@@ -5,4 +5,12 @@ set(SPQLIOX_AARCH64_HEADERS fft_processor_spqliox_aarch64.h
 add_library(spqliox_aarch64 STATIC ${SPQLIOX_AARCH64_SRCS}
                                    ${SPQLIOX_AARCH64_HEADERS})
 
-target_include_directories(spqliox_aarch64 PUBLIC ${PROJECT_SOURCE_DIR}/include)
+# Check if the platform is macOS and the architecture is ARM64
+if(APPLE AND CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
+  # Add the include directory provided by Homebrew
+  target_include_directories(
+    spqliox_aarch64 PUBLIC ${PROJECT_SOURCE_DIR}/include /opt/homebrew/include)
+else()
+  target_include_directories(spqliox_aarch64
+                             PUBLIC ${PROJECT_SOURCE_DIR}/include)
+endif()