Replaced usint, corrected usage of const, added docs (#214)

Co-authored-by: Dmitriy Suponitskiy <dsuponitskiy@dualitytech.com>

src/include/docstrings/cryptocontext_docs.h

@@ -977,7 +977,7 @@ const char* cc_MultiEvalAtIndexKeyGen_docs = R"pbdoc(
     :type indexList: List[int32]
     :param keyId: new key identifier used for resulting evaluation key
     :type keyId: str
-    :return: EvalKeyMap: new joined rotation keys
+    :return: EvalKeyMap: a map with new joined rotation keys
     :rtype: EvalKeyMap
 )pbdoc";
 
@@ -1136,10 +1136,12 @@ const char* cc_InsertEvalMultKey_docs = R"pbdoc(
 )pbdoc";
 
 const char* cc_InsertEvalAutomorphismKey_docs = R"pbdoc(
-    Add the given map of keys to the map, replacing the existing map if there is
+    Add the given map of keys to the map, replacing the existing map if there is one
 
-    :param evalKeyMap: map of keys
+    :param evalKeyMap: map of keys to be inserted
     :type EvalKeyMap
+    :param keyTag: key identifier for the given key map
+    :type keyTag: str
 )pbdoc";
 
 const char* cc_EvalSum_docs = R"pbdoc(

src/include/pke/cryptocontext_wrapper.h

@@ -41,10 +41,10 @@ Ciphertext<DCRTPoly> EvalFastRotationPrecomputeWrapper(CryptoContext<DCRTPoly> &
 
 Ciphertext<DCRTPoly> EvalFastRotationWrapper(CryptoContext<DCRTPoly> &self,
                                              ConstCiphertext<DCRTPoly> ciphertext,
-                                             const usint index,
-                                             const usint m,
+                                             uint32_t index,
+                                             uint32_t m,
                                              ConstCiphertext<DCRTPoly> digits);
-Ciphertext<DCRTPoly> EvalFastRotationExtWrapper(CryptoContext<DCRTPoly> &self, ConstCiphertext<DCRTPoly> ciphertext, const usint index, ConstCiphertext<DCRTPoly> digits, bool addFirst);
+Ciphertext<DCRTPoly> EvalFastRotationExtWrapper(CryptoContext<DCRTPoly> &self, ConstCiphertext<DCRTPoly> ciphertext, uint32_t index, ConstCiphertext<DCRTPoly> digits, bool addFirst);
 
 Plaintext DecryptWrapper(CryptoContext<DCRTPoly> &self,
                          ConstCiphertext<DCRTPoly> ciphertext, const PrivateKey<DCRTPoly> privateKey);
@@ -52,14 +52,14 @@ Plaintext DecryptWrapper(CryptoContext<DCRTPoly> &self,
                          const PrivateKey<DCRTPoly> privateKey, ConstCiphertext<DCRTPoly> ciphertext);
 Plaintext MultipartyDecryptFusionWrapper(CryptoContext<DCRTPoly>& self,const std::vector<Ciphertext<DCRTPoly>>& partialCiphertextVec);
 
-const std::shared_ptr<std::map<usint, EvalKey<DCRTPoly>>> GetEvalSumKeyMapWrapper(CryptoContext<DCRTPoly>& self, const std::string &id);
-const PlaintextModulus GetPlaintextModulusWrapper(CryptoContext<DCRTPoly>& self);
-const double GetModulusWrapper(CryptoContext<DCRTPoly>& self);
-void RemoveElementWrapper(Ciphertext<DCRTPoly>& self, usint index);
-const double GetScalingFactorRealWrapper(CryptoContext<DCRTPoly>& self, uint32_t l);
-const uint64_t GetModulusCKKSWrapper(CryptoContext<DCRTPoly>& self);
-const ScalingTechnique GetScalingTechniqueWrapper(CryptoContext<DCRTPoly>& self);
-const usint GetDigitSizeWrapper(CryptoContext<DCRTPoly>& self);
+const std::shared_ptr<std::map<uint32_t, EvalKey<DCRTPoly>>> GetEvalSumKeyMapWrapper(CryptoContext<DCRTPoly>& self, const std::string &id);
+PlaintextModulus GetPlaintextModulusWrapper(CryptoContext<DCRTPoly>& self);
+double GetModulusWrapper(CryptoContext<DCRTPoly>& self);
+void RemoveElementWrapper(Ciphertext<DCRTPoly>& self, uint32_t index);
+double GetScalingFactorRealWrapper(CryptoContext<DCRTPoly>& self, uint32_t l);
+uint64_t GetModulusCKKSWrapper(CryptoContext<DCRTPoly>& self);
+ScalingTechnique GetScalingTechniqueWrapper(CryptoContext<DCRTPoly>& self);
+uint32_t GetDigitSizeWrapper(CryptoContext<DCRTPoly>& self);
 
 void ClearEvalMultKeysWrapper();
 

src/lib/bindings.cpp

@@ -52,7 +52,7 @@ using namespace lbcrypto;
 namespace py = pybind11;
 
 // disable the PYBIND11 template-based conversion for this type
-PYBIND11_MAKE_OPAQUE(std::map<usint, EvalKey<DCRTPoly>>);
+PYBIND11_MAKE_OPAQUE(std::map<uint32_t, EvalKey<DCRTPoly>>);
 
 template <typename T>
 void bind_parameters(py::module &m,const std::string name)
@@ -183,13 +183,13 @@ void bind_crypto_context(py::module &m)
             py::arg("noiseScaleDeg ") = 1,
             py::arg("level") = 0)
         // TODO (Oliveira): allow user to specify different params values
-        .def("MakeCKKSPackedPlaintext", static_cast<Plaintext (CryptoContextImpl<DCRTPoly>::*)(const std::vector<std::complex<double>> &, size_t, uint32_t, const std::shared_ptr<ParmType>, usint) const>(&CryptoContextImpl<DCRTPoly>::MakeCKKSPackedPlaintext), cc_MakeCKKSPackedPlaintextComplex_docs,
+        .def("MakeCKKSPackedPlaintext", static_cast<Plaintext (CryptoContextImpl<DCRTPoly>::*)(const std::vector<std::complex<double>> &, size_t, uint32_t, const std::shared_ptr<ParmType>, uint32_t) const>(&CryptoContextImpl<DCRTPoly>::MakeCKKSPackedPlaintext), cc_MakeCKKSPackedPlaintextComplex_docs,
              py::arg("value"),
              py::arg("scaleDeg") = static_cast<size_t>(1),
              py::arg("level") = static_cast<uint32_t>(0),
              py::arg("params") = py::none(),
              py::arg("slots") = 0)
-        .def("MakeCKKSPackedPlaintext", static_cast<Plaintext (CryptoContextImpl<DCRTPoly>::*)(const std::vector<double> &, size_t, uint32_t, const std::shared_ptr<ParmType>, usint) const>(&CryptoContextImpl<DCRTPoly>::MakeCKKSPackedPlaintext), cc_MakeCKKSPlaintextReal_docs,
+        .def("MakeCKKSPackedPlaintext", static_cast<Plaintext (CryptoContextImpl<DCRTPoly>::*)(const std::vector<double> &, size_t, uint32_t, const std::shared_ptr<ParmType>, uint32_t) const>(&CryptoContextImpl<DCRTPoly>::MakeCKKSPackedPlaintext), cc_MakeCKKSPlaintextReal_docs,
              py::arg("value"),
              py::arg("scaleDeg") = static_cast<size_t>(1),
              py::arg("level") = static_cast<uint32_t>(0),
@@ -240,28 +240,27 @@ void bind_crypto_context(py::module &m)
             cc_KeySwitchGen_docs,
             py::arg("oldPrivateKey"),
             py::arg("newPrivateKey"))
-        .def("EvalAdd", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstCiphertext<DCRTPoly>) const>
+        .def("EvalAdd", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, const ConstCiphertext<DCRTPoly>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalAdd), 
             cc_EvalAdd_docs,
             py::arg("ciphertext1"),
             py::arg("ciphertext2"))
-        .def("EvalAdd", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, double) const>
+        .def("EvalAdd", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, double) const>
             (&CryptoContextImpl<DCRTPoly>::EvalAdd), 
             cc_EvalAddfloat_docs,
             py::arg("ciphertext"),
-            py::arg("constant"))
-        //inline Ciphertext<Element> EvalAdd(ConstCiphertext<Element> ciphertext, ConstPlaintext plaintext) const
-        .def("EvalAdd", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstPlaintext) const>
+            py::arg("scalar"))
+        .def("EvalAdd", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, ConstPlaintext) const>
             (&CryptoContextImpl<DCRTPoly>::EvalAdd),
             cc_EvalAddPlaintext_docs,
             py::arg("ciphertext"),
             py::arg("plaintext"))
-        .def("EvalAddInPlace", static_cast<void (CryptoContextImpl<DCRTPoly>::*)(Ciphertext<DCRTPoly> &, ConstCiphertext<DCRTPoly>) const>
+        .def("EvalAddInPlace", static_cast<void (CryptoContextImpl<DCRTPoly>::*)(Ciphertext<DCRTPoly>&, const ConstCiphertext<DCRTPoly>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalAddInPlace),
             cc_EvalAddInPlace_docs,
             py::arg("ciphertext1"),
             py::arg("ciphertext2"))
-        .def("EvalAddInPlace", static_cast<void (CryptoContextImpl<DCRTPoly>::*)(Ciphertext<DCRTPoly> &, ConstPlaintext) const>
+        .def("EvalAddInPlace", static_cast<void (CryptoContextImpl<DCRTPoly>::*)(Ciphertext<DCRTPoly>&, ConstPlaintext) const>
             (&CryptoContextImpl<DCRTPoly>::EvalAddInPlace),
             cc_EvalAddInPlacePlaintext_docs,
             py::arg("ciphertext"),
@@ -290,32 +289,32 @@ void bind_crypto_context(py::module &m)
             cc_EvalAddMutableInPlace_docs,
             py::arg("ciphertext1"),
             py::arg("ciphertext2"))
-        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstCiphertext<DCRTPoly>) const>
+        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, const ConstCiphertext<DCRTPoly>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalSub),
             cc_EvalSub_docs,
             py::arg("ciphertext1"),
             py::arg("ciphertext2"))
-        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, double) const>
+        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, double) const>
             (&CryptoContextImpl<DCRTPoly>::EvalSub),
             cc_EvalSubfloat_docs,
             py::arg("ciphertext"),
-            py::arg("constant"))
-        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(double, ConstCiphertext<DCRTPoly>) const>
+            py::arg("scalar"))
+        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(double, const ConstCiphertext<DCRTPoly>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalSub),
             "",
-            py::arg("constant"),
+            py::arg("scalar"),
             py::arg("ciphertext"))
-        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstPlaintext) const>
+        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, ConstPlaintext) const>
             (&CryptoContextImpl<DCRTPoly>::EvalSub),
             cc_EvalSubPlaintext_docs,
             py::arg("ciphertext"),
             py::arg("plaintext"))
-        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstPlaintext, ConstCiphertext<DCRTPoly>) const>
+        .def("EvalSub", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstPlaintext, const ConstCiphertext<DCRTPoly>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalSub),
             "",
             py::arg("plaintext"),
             py::arg("ciphertext"))
-        .def("EvalSubInPlace", static_cast<void (CryptoContextImpl<DCRTPoly>::*)(Ciphertext<DCRTPoly> &, ConstCiphertext<DCRTPoly>) const>
+        .def("EvalSubInPlace", static_cast<void (CryptoContextImpl<DCRTPoly>::*)(Ciphertext<DCRTPoly> &, const ConstCiphertext<DCRTPoly>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalSubInPlace),
             cc_EvalSubInPlace_docs,
             py::arg("ciphertext1"),
@@ -324,11 +323,11 @@ void bind_crypto_context(py::module &m)
             (&CryptoContextImpl<DCRTPoly>::EvalSubInPlace),
             cc_EvalSubInPlacefloat_docs,
             py::arg("ciphertext"),
-            py::arg("constant"))
+            py::arg("scalar"))
         .def("EvalSubInPlace", static_cast<void (CryptoContextImpl<DCRTPoly>::*)(double, Ciphertext<DCRTPoly> &) const>
             (&CryptoContextImpl<DCRTPoly>::EvalSubInPlace),
             "",
-            py::arg("constant"),
+            py::arg("scalar"),
             py::arg("ciphertext"))
         .def("EvalSubMutable", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(Ciphertext<DCRTPoly> &, Ciphertext<DCRTPoly> &) const>
             (&CryptoContextImpl<DCRTPoly>::EvalSubMutable),
@@ -349,30 +348,30 @@ void bind_crypto_context(py::module &m)
             cc_EvalSubMutableInPlace_docs,
             py::arg("ciphertext1"),
             py::arg("ciphertext2"))
-        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstCiphertext<DCRTPoly>) const>
+        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, const ConstCiphertext<DCRTPoly>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalMult),
             cc_EvalMult_docs,
             py::arg("ciphertext1"),
             py::arg("ciphertext2"))
-        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, double) const>
+        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, double) const>
             (&CryptoContextImpl<DCRTPoly>::EvalMult),
             cc_EvalMultfloat_docs,
             py::arg("ciphertext"),
-            py::arg("constant"))
-        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstPlaintext) const>
+            py::arg("scalar"))
+        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, ConstPlaintext) const>
             (&CryptoContextImpl<DCRTPoly>::EvalMult),
             cc_EvalMultPlaintext_docs,
             py::arg("ciphertext"),
             py::arg("plaintext"))
-        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstPlaintext, ConstCiphertext<DCRTPoly>) const>
+        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstPlaintext, const ConstCiphertext<DCRTPoly>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalMult),
             "",
             py::arg("plaintext"),
             py::arg("ciphertext"))
-        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(double, ConstCiphertext<DCRTPoly>) const>
+        .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(double, const ConstCiphertext<DCRTPoly>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalMult),
             "",
-            py::arg("constant"),
+            py::arg("scalar"),
             py::arg("ciphertext"))
         .def("EvalMultMutable", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(Ciphertext<DCRTPoly> &, Ciphertext<DCRTPoly> &) const>
             (&CryptoContextImpl<DCRTPoly>::EvalMultMutable),
@@ -501,12 +500,12 @@ void bind_crypto_context(py::module &m)
              py::arg("ciphertext"),
              py::arg("rowSize"),
              py::arg("evalSumKeyMap"))
-        .def("EvalInnerProduct", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstCiphertext<DCRTPoly>, usint) const>(&CryptoContextImpl<DCRTPoly>::EvalInnerProduct),
+        .def("EvalInnerProduct", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, const ConstCiphertext<DCRTPoly>&, uint32_t) const>(&CryptoContextImpl<DCRTPoly>::EvalInnerProduct),
              cc_EvalInnerProduct_docs,
              py::arg("ciphertext1"),
              py::arg("ciphertext2"),
              py::arg("batchSize"))
-        .def("EvalInnerProduct", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstPlaintext, usint) const>(&CryptoContextImpl<DCRTPoly>::EvalInnerProduct),
+        .def("EvalInnerProduct", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(const ConstCiphertext<DCRTPoly>&, ConstPlaintext, uint32_t) const>(&CryptoContextImpl<DCRTPoly>::EvalInnerProduct),
              cc_EvalInnerProductPlaintext_docs,
              py::arg("ciphertext"),
              py::arg("plaintext"),
@@ -540,39 +539,39 @@ void bind_crypto_context(py::module &m)
                 const PrivateKey<DCRTPoly>& privateKey,
                 std::shared_ptr<std::map<unsigned int, EvalKey<DCRTPoly>>> evalKeyMap,
                 const std::vector<int32_t>& indexList,
-                const std::string& keyId = "") {
-                 return self->MultiEvalAtIndexKeyGen(privateKey, evalKeyMap, indexList, keyId);
+                const std::string& keyTag = "") {
+              return self->MultiEvalAtIndexKeyGen(privateKey, evalKeyMap, indexList, keyTag);
              },
              cc_MultiEvalAtIndexKeyGen_docs,
              py::arg("privateKey"),
              py::arg("evalKeyMap"),
              py::arg("indexList"),
-             py::arg("keyId") = "")
+             py::arg("keyTag") = "")
         .def("MultiEvalSumKeyGen", &CryptoContextImpl<DCRTPoly>::MultiEvalSumKeyGen,
              cc_MultiEvalSumKeyGen_docs,
              py::arg("privateKey"),
              py::arg("evalKeyMap"),
-             py::arg("keyId") = "")
+             py::arg("keyTag") = "")
         .def("MultiAddEvalAutomorphismKeys", &CryptoContextImpl<DCRTPoly>::MultiAddEvalAutomorphismKeys,
             cc_MultiAddEvalAutomorphismKeys_docs,
             py::arg("evalKeyMap1"),
             py::arg("evalKeyMap1"),
-            py::arg("keyId") = "")
+            py::arg("keyTag") = "")
         .def("MultiAddPubKeys", &CryptoContextImpl<DCRTPoly>::MultiAddPubKeys,
             cc_MultiAddPubKeys_docs,
             py::arg("publicKey1"),
             py::arg("publicKey2"),
-            py::arg("keyId") = "")
+            py::arg("keyTag") = "")
         .def("MultiAddEvalKeys", &CryptoContextImpl<DCRTPoly>::MultiAddEvalKeys,
              cc_MultiAddEvalKeys_docs,
              py::arg("evalKey1"),
              py::arg("evalKey2"),
-             py::arg("keyId") = "")
+             py::arg("keyTag") = "")
         .def("MultiAddEvalMultKeys", &CryptoContextImpl<DCRTPoly>::MultiAddEvalMultKeys,
              cc_MultiAddEvalMultKeys_docs,
              py::arg("evalKey1"),
              py::arg("evalKey2"),
-             py::arg("keyId") = "")
+             py::arg("keyTag") = "")
         .def("IntMPBootAdjustScale",&CryptoContextImpl<DCRTPoly>::IntMPBootAdjustScale,
              cc_IntMPBootAdjustScale_docs,
              py::arg("ciphertext"))
@@ -597,12 +596,12 @@ void bind_crypto_context(py::module &m)
              cc_MultiMultEvalKey_docs,
              py::arg("privateKey"),
              py::arg("evalKey"),
-             py::arg("keyId") = "")
+             py::arg("keyTag") = "")
         .def("MultiAddEvalSumKeys", &CryptoContextImpl<DCRTPoly>::MultiAddEvalSumKeys,
              cc_MultiAddEvalSumKeys_docs,
              py::arg("evalKeyMap1"),
              py::arg("evalKeyMap2"),
-             py::arg("keyId") = "")
+             py::arg("keyTag") = "")
         .def("EvalMerge", &CryptoContextImpl<DCRTPoly>::EvalMerge,
              cc_EvalMerge_docs,
              py::arg("ciphertextVec"))
@@ -748,7 +747,7 @@ void bind_crypto_context(py::module &m)
              py::arg("scaleSign") = 1.0)
         //TODO (Oliveira, R.): Solve pointer handling bug when returning EvalKeyMap objects for the next functions
         .def("EvalAutomorphismKeyGen",
-            static_cast<std::shared_ptr<std::map<usint, EvalKey<DCRTPoly>>> (CryptoContextImpl<DCRTPoly>::*)(const PrivateKey<DCRTPoly>, const std::vector<usint>&) const>
+            static_cast<std::shared_ptr<std::map<uint32_t, EvalKey<DCRTPoly>>> (CryptoContextImpl<DCRTPoly>::*)(const PrivateKey<DCRTPoly>, const std::vector<uint32_t>&) const>
             (&CryptoContextImpl<DCRTPoly>::EvalAutomorphismKeyGen), 
             cc_EvalAutomorphismKeyGen_docs,
             py::arg("privateKey"),
@@ -759,14 +758,14 @@ void bind_crypto_context(py::module &m)
                 std::vector<std::shared_ptr<lbcrypto::CiphertextImpl<DCRTPoly> > >&
             ) const>(
             &CryptoContextImpl<DCRTPoly>::EvalLinearWSumMutable),
-            py::arg("ciphertext"),
-            py::arg("coefficients"))
+             py::arg("ciphertext"),
+             py::arg("coefficients"))
         .def("EvalLinearWSum",
             static_cast<lbcrypto::Ciphertext<DCRTPoly> (lbcrypto::CryptoContextImpl<DCRTPoly>::*)(
             std::vector<std::shared_ptr<const lbcrypto::CiphertextImpl<DCRTPoly> > >&,const std::vector<double>&) const>(
             &CryptoContextImpl<DCRTPoly>::EvalLinearWSum),
-            py::arg("ciphertext"),
-            py::arg("coefficients"))
+             py::arg("ciphertext"),
+             py::arg("coefficients"))
        .def("Compress", &CryptoContextImpl<DCRTPoly>::Compress,
             py::arg("ciphertext"),
             py::arg("towersLeft"))
@@ -806,93 +805,93 @@ void bind_crypto_context(py::module &m)
             cc_ClearEvalAutomorphismKeys_docs)
         // it is safer to return by value instead of by reference (GetEvalMultKeyVector returns a const reference to std::vector)
         .def_static("GetEvalMultKeyVector",
-            [](const std::string& keyId) {
-                return CryptoContextImpl<DCRTPoly>::GetEvalMultKeyVector(keyId);
+            [](const std::string& keyTag) {
+              return CryptoContextImpl<DCRTPoly>::GetEvalMultKeyVector(keyTag);
             },
             cc_GetEvalMultKeyVector_docs,
-            py::arg("keyId") = "")
+            py::arg("keyTag") = "")
         .def_static("GetEvalAutomorphismKeyMap", &CryptoContextImpl<DCRTPoly>::GetEvalAutomorphismKeyMapPtr,
             cc_GetEvalAutomorphismKeyMap_docs,
-            py::arg("keyId") = "")
+            py::arg("keyTag") = "")
         .def_static(
-            "SerializeEvalMultKey", [](const std::string &filename, const SerType::SERBINARY &sertype, std::string id = "")
+            "SerializeEvalMultKey", [](const std::string &filename, const SerType::SERBINARY &sertype, std::string keyTag = "")
             {
-                std::ofstream outfile(filename,std::ios::out | std::ios::binary);
-                bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey<SerType::SERBINARY>(outfile, sertype, id);
-                outfile.close();
-                return res; },
+              std::ofstream outfile(filename, std::ios::out | std::ios::binary);
+              bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey<SerType::SERBINARY>(outfile, sertype, keyTag);
+              outfile.close();
+              return res; },
             cc_SerializeEvalMultKey_docs,
-            py::arg("filename"), py::arg("sertype"), py::arg("id") = "")
+            py::arg("filename"), py::arg("sertype"), py::arg("keyTag") = "")
         .def_static( // SerializeEvalMultKey - JSON
-            "SerializeEvalMultKey", [](const std::string &filename, const SerType::SERJSON &sertype, std::string id = "")
+            "SerializeEvalMultKey", [](const std::string &filename, const SerType::SERJSON &sertype, std::string keyTag = "")
             {
-                std::ofstream outfile(filename,std::ios::out | std::ios::binary);
-                bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey<SerType::SERJSON>(outfile, sertype, id);
-                outfile.close();
-                return res; },
+              std::ofstream outfile(filename, std::ios::out | std::ios::binary);
+              bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey<SerType::SERJSON>(outfile, sertype, keyTag);
+              outfile.close();
+              return res; },
             cc_SerializeEvalMultKey_docs,
-            py::arg("filename"), py::arg("sertype"), py::arg("id") = "")
+            py::arg("filename"), py::arg("sertype"), py::arg("keyTag") = "")
         .def_static( // SerializeEvalAutomorphismKey - Binary
-            "SerializeEvalAutomorphismKey", [](const std::string &filename, const SerType::SERBINARY &sertype, std::string id = "")
+            "SerializeEvalAutomorphismKey", [](const std::string &filename, const SerType::SERBINARY &sertype, std::string keyTag = "")
             {
-                std::ofstream outfile(filename,std::ios::out | std::ios::binary);
-                bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey<SerType::SERBINARY>(outfile, sertype, id);
-                outfile.close();
-                return res; },
+              std::ofstream outfile(filename, std::ios::out | std::ios::binary);
+              bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey<SerType::SERBINARY>(outfile, sertype, keyTag);
+              outfile.close();
+              return res; },
             cc_SerializeEvalAutomorphismKey_docs,
-            py::arg("filename"), py::arg("sertype"), py::arg("id") = "")
+            py::arg("filename"), py::arg("sertype"), py::arg("keyTag") = "")
         .def_static( // SerializeEvalAutomorphismKey - JSON
-            "SerializeEvalAutomorphismKey", [](const std::string &filename, const SerType::SERJSON &sertype, std::string id = "")
+            "SerializeEvalAutomorphismKey", [](const std::string &filename, const SerType::SERJSON &sertype, std::string keyTag = "")
             {
-                std::ofstream outfile(filename,std::ios::out | std::ios::binary);
-                bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey<SerType::SERJSON>(outfile, sertype, id);
-                outfile.close();
-                return res; },
+              std::ofstream outfile(filename, std::ios::out | std::ios::binary);
+              bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey<SerType::SERJSON>(outfile, sertype, keyTag);
+              outfile.close();
+              return res; },
             cc_SerializeEvalAutomorphismKey_docs,
-            py::arg("filename"), py::arg("sertype"), py::arg("id") = "")
+            py::arg("filename"), py::arg("sertype"), py::arg("keyTag") = "")
         .def_static("DeserializeEvalMultKey", // DeserializeEvalMultKey - Binary
         [](const std::string &filename, const SerType::SERBINARY &sertype)
                     {
-                        std::ifstream emkeys(filename, std::ios::in | std::ios::binary);
-                         if (!emkeys.is_open()) {
-                            std::cerr << "I cannot read serialization from " << filename << std::endl;
-                         }
-                        bool res = CryptoContextImpl<DCRTPoly>::DeserializeEvalMultKey<SerType::SERBINARY>(emkeys, sertype);
-                        return res;
+              std::ifstream emkeys(filename, std::ios::in | std::ios::binary);
+              if (!emkeys.is_open()) {
+                std::cerr << "I cannot read serialization from " << filename << std::endl;
+              }
+              bool res = CryptoContextImpl<DCRTPoly>::DeserializeEvalMultKey<SerType::SERBINARY>(emkeys, sertype);
+              return res; 
                         },
                         cc_DeserializeEvalMultKey_docs,
                         py::arg("filename"), py::arg("sertype"))
         .def_static("DeserializeEvalMultKey", // DeserializeEvalMultKey - JSON
         [](const std::string &filename, const SerType::SERJSON &sertype)
                     {
-                        std::ifstream emkeys(filename, std::ios::in | std::ios::binary);
-                         if (!emkeys.is_open()) {
-                            std::cerr << "I cannot read serialization from " << filename << std::endl;
-                         }
-                        bool res = CryptoContextImpl<DCRTPoly>::DeserializeEvalMultKey<SerType::SERJSON>(emkeys, sertype);
-                        return res; },
+              std::ifstream emkeys(filename, std::ios::in | std::ios::binary);
+              if (!emkeys.is_open()) {
+                std::cerr << "I cannot read serialization from " << filename << std::endl;
+              }
+              bool res = CryptoContextImpl<DCRTPoly>::DeserializeEvalMultKey<SerType::SERJSON>(emkeys, sertype);
+              return res; },
                         cc_DeserializeEvalMultKey_docs,
                         py::arg("filename"), py::arg("sertype"))
         .def_static("DeserializeEvalAutomorphismKey", // DeserializeEvalAutomorphismKey - Binary
         [](const std::string &filename, const SerType::SERBINARY &sertype)
                     {
-                        std::ifstream erkeys(filename, std::ios::in | std::ios::binary);
-                         if (!erkeys.is_open()) {
-                            std::cerr << "I cannot read serialization from " << filename << std::endl;
-                         }
-                        bool res = CryptoContextImpl<DCRTPoly>::DeserializeEvalAutomorphismKey<SerType::SERBINARY>(erkeys, sertype);
-                        return res; },
+              std::ifstream erkeys(filename, std::ios::in | std::ios::binary);
+              if (!erkeys.is_open()) {
+                std::cerr << "I cannot read serialization from " << filename << std::endl;
+              }
+              bool res = CryptoContextImpl<DCRTPoly>::DeserializeEvalAutomorphismKey<SerType::SERBINARY>(erkeys, sertype);
+              return res; },
                         cc_DeserializeEvalAutomorphismKey_docs,
                         py::arg("filename"), py::arg("sertype"))
         .def_static("DeserializeEvalAutomorphismKey", // DeserializeEvalAutomorphismKey - JSON
         [](const std::string &filename, const SerType::SERJSON &sertype)
                     {
-                        std::ifstream erkeys(filename, std::ios::in | std::ios::binary);
-                         if (!erkeys.is_open()) {
-                            std::cerr << "I cannot read serialization from " << filename << std::endl;
-                         }
-                        bool res = CryptoContextImpl<DCRTPoly>::DeserializeEvalAutomorphismKey<SerType::SERJSON>(erkeys, sertype);
-                        return res; },
+              std::ifstream erkeys(filename, std::ios::in | std::ios::binary);
+              if (!erkeys.is_open()) {
+                std::cerr << "I cannot read serialization from " << filename << std::endl;
+              }
+              bool res = CryptoContextImpl<DCRTPoly>::DeserializeEvalAutomorphismKey<SerType::SERJSON>(erkeys, sertype);
+              return res; },
                         cc_DeserializeEvalAutomorphismKey_docs,
                         py::arg("filename"), py::arg("sertype"));
 
@@ -1091,7 +1090,7 @@ void bind_keys(py::module &m)
         .def(py::init<>())
         .def("GetKeyTag", &EvalKeyImpl<DCRTPoly>::GetKeyTag)
         .def("SetKeyTag", &EvalKeyImpl<DCRTPoly>::SetKeyTag);
-    py::class_<std::map<usint, EvalKey<DCRTPoly>>, std::shared_ptr<std::map<usint, EvalKey<DCRTPoly>>>>(m, "EvalKeyMap")
+    py::class_<std::map<uint32_t, EvalKey<DCRTPoly>>, std::shared_ptr<std::map<uint32_t, EvalKey<DCRTPoly>>>>(m, "EvalKeyMap")
         .def(py::init<>());
 }
 

src/lib/pke/cryptocontext_wrapper.cpp

@@ -39,14 +39,14 @@ Ciphertext<DCRTPoly> EvalFastRotationPrecomputeWrapper(CryptoContext<DCRTPoly> &
     cipherdigitsPtr->SetElements(elements);
     return cipherdigitsPtr;
 }
-Ciphertext<DCRTPoly> EvalFastRotationWrapper(CryptoContext<DCRTPoly>& self,ConstCiphertext<DCRTPoly> ciphertext, const usint index, const usint m,ConstCiphertext<DCRTPoly> digits) {
+Ciphertext<DCRTPoly> EvalFastRotationWrapper(CryptoContext<DCRTPoly>& self,ConstCiphertext<DCRTPoly> ciphertext, uint32_t index, uint32_t m,ConstCiphertext<DCRTPoly> digits) {
     
         std::vector<DCRTPoly> digitsElements = digits->GetElements();
         std::shared_ptr<std::vector<DCRTPoly>> digitsElementsPtr = std::make_shared<std::vector<DCRTPoly>>(digitsElements);
         return self->EvalFastRotation(ciphertext, index, m, digitsElementsPtr);
     }
 
-Ciphertext<DCRTPoly> EvalFastRotationExtWrapper(CryptoContext<DCRTPoly>& self,ConstCiphertext<DCRTPoly> ciphertext, const usint index, ConstCiphertext<DCRTPoly> digits, bool addFirst) {
+Ciphertext<DCRTPoly> EvalFastRotationExtWrapper(CryptoContext<DCRTPoly>& self,ConstCiphertext<DCRTPoly> ciphertext, uint32_t index, ConstCiphertext<DCRTPoly> digits, bool addFirst) {
     std::vector<DCRTPoly> digitsElements = digits->GetElements();
     std::shared_ptr<std::vector<DCRTPoly>> digitsElementsPtr = std::make_shared<std::vector<DCRTPoly>>(digitsElements);
     return self->EvalFastRotationExt(ciphertext, index, digitsElementsPtr, addFirst);
@@ -70,26 +70,26 @@ Plaintext MultipartyDecryptFusionWrapper(CryptoContext<DCRTPoly>& self,const std
     return plaintextDecResult;
 }
 
-const std::shared_ptr<std::map<usint, EvalKey<DCRTPoly>>> GetEvalSumKeyMapWrapper(CryptoContext<DCRTPoly>& self,const std::string &id){
-    return std::make_shared<std::map<usint, EvalKey<DCRTPoly>>>(CryptoContextImpl<DCRTPoly>::GetEvalSumKeyMap(id));;
+const std::shared_ptr<std::map<uint32_t, EvalKey<DCRTPoly>>> GetEvalSumKeyMapWrapper(CryptoContext<DCRTPoly>& self,const std::string &keyTag){
+    return std::make_shared<std::map<uint32_t, EvalKey<DCRTPoly>>>(CryptoContextImpl<DCRTPoly>::GetEvalSumKeyMap(keyTag));;
 }
 
-const PlaintextModulus GetPlaintextModulusWrapper(CryptoContext<DCRTPoly>& self){
+PlaintextModulus GetPlaintextModulusWrapper(CryptoContext<DCRTPoly>& self){
     return self->GetCryptoParameters()->GetPlaintextModulus();
 }
 
-const double GetModulusWrapper(CryptoContext<DCRTPoly>& self){
+double GetModulusWrapper(CryptoContext<DCRTPoly>& self){
     return self->GetCryptoParameters()->GetElementParams()->GetModulus().ConvertToDouble();
 }
 
-void RemoveElementWrapper(Ciphertext<DCRTPoly> &self, usint index){
+void RemoveElementWrapper(Ciphertext<DCRTPoly> &self, uint32_t index){
     self->GetElements().erase(self->GetElements().begin()+index);
 }
-const usint GetDigitSizeWrapper(CryptoContext<DCRTPoly>& self){
+uint32_t GetDigitSizeWrapper(CryptoContext<DCRTPoly>& self){
     return self->GetCryptoParameters()->GetDigitSize();
 }
 
-const double GetScalingFactorRealWrapper(CryptoContext<DCRTPoly>& self, uint32_t l){
+double GetScalingFactorRealWrapper(CryptoContext<DCRTPoly>& self, uint32_t l){
     if(self->getSchemeId()==SCHEME::CKKSRNS_SCHEME){
         const auto cryptoParams = std::dynamic_pointer_cast<CryptoParametersCKKSRNS>(self->GetCryptoParameters());
         double scFactor = cryptoParams->GetScalingFactorReal(l);
@@ -111,7 +111,7 @@ const double GetScalingFactorRealWrapper(CryptoContext<DCRTPoly>& self, uint32_t
     }
 }
 
-const uint64_t GetModulusCKKSWrapper(CryptoContext<DCRTPoly> &self)
+uint64_t GetModulusCKKSWrapper(CryptoContext<DCRTPoly> &self)
 {
 
     const auto cryptoParams = std::dynamic_pointer_cast<CryptoParametersCKKSRNS>(self->GetCryptoParameters());
@@ -121,7 +121,7 @@ const uint64_t GetModulusCKKSWrapper(CryptoContext<DCRTPoly> &self)
     return modulus_CKKS_from;
 }
 
-const ScalingTechnique GetScalingTechniqueWrapper(CryptoContext<DCRTPoly> & self){
+ScalingTechnique GetScalingTechniqueWrapper(CryptoContext<DCRTPoly> & self){
     if(self->getSchemeId()==SCHEME::CKKSRNS_SCHEME){
         const auto cryptoParams = std::dynamic_pointer_cast<CryptoParametersCKKSRNS>(self->GetCryptoParameters());
         return cryptoParams->GetScalingTechnique();

src/lib/pke/serialization.cpp

@@ -47,17 +47,17 @@ PYBIND11_MAKE_OPAQUE(std::map<uint32_t, EvalKey<DCRTPoly>>);
 
 
 template <typename ST>
-bool SerializeEvalMultKeyWrapper(const std::string& filename, const ST& sertype, std::string id) {
+bool SerializeEvalMultKeyWrapper(const std::string& filename, const ST& sertype, std::string keyTag) {
     std::ofstream outfile(filename, std::ios::out | std::ios::binary);
-    bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey<ST>(outfile, sertype, id);
+    bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey<ST>(outfile, sertype, keyTag);
     outfile.close();
     return res;
 }
 
 template <typename ST>
-bool SerializeEvalAutomorphismKeyWrapper(const std::string& filename, const ST& sertype, std::string id) {
+bool SerializeEvalAutomorphismKeyWrapper(const std::string& filename, const ST& sertype, std::string keyTag) {
     std::ofstream outfile(filename, std::ios::out | std::ios::binary);
-    bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey<ST>(outfile, sertype, id);
+    bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey<ST>(outfile, sertype, keyTag);
     outfile.close();
     return res;
 }
@@ -141,9 +141,9 @@ CryptoContext<DCRTPoly> DeserializeCCFromBytesWrapper(const py::bytes& bytes, co
 }
 
 template <typename ST>
-std::string SerializeEvalMultKeyToStringWrapper(const ST& sertype, const std::string& id) {
+std::string SerializeEvalMultKeyToStringWrapper(const ST& sertype, const std::string& keyTag) {
     std::ostringstream oss;
-    bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey(oss, sertype, id);
+    bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey(oss, sertype, keyTag);
     if (!res) {
         throw std::runtime_error("Failed to serialize EvalMultKey");
     }
@@ -151,12 +151,12 @@ std::string SerializeEvalMultKeyToStringWrapper(const ST& sertype, const std::st
 }
 
 template <typename ST>
-py::bytes SerializeEvalMultKeyToBytesWrapper(const ST& sertype, const std::string& id) {
+py::bytes SerializeEvalMultKeyToBytesWrapper(const ST& sertype, const std::string& keyTag) {
     // let strbuf be dynamically allocated as we may be dealing with large keys
     auto strbuf = std::make_unique<std::stringbuf>(std::ios::out | std::ios::binary);
     std::ostream oss(strbuf.get());
 
-    if (!CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey(oss, sertype, id)) {
+    if (!CryptoContextImpl<DCRTPoly>::SerializeEvalMultKey(oss, sertype, keyTag)) {
         throw std::runtime_error("Failed to serialize EvalMultKey");
     }
 
@@ -165,9 +165,9 @@ py::bytes SerializeEvalMultKeyToBytesWrapper(const ST& sertype, const std::strin
 }
 
 template <typename ST>
-std::string SerializeEvalAutomorphismKeyToStringWrapper(const ST& sertype, const std::string& id) {
+std::string SerializeEvalAutomorphismKeyToStringWrapper(const ST& sertype, const std::string& keyTag) {
     std::ostringstream oss;
-    bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey(oss, sertype, id);
+    bool res = CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey(oss, sertype, keyTag);
     if (!res) {
         throw std::runtime_error("Failed to serialize EvalAutomorphismKey");
     }
@@ -175,12 +175,12 @@ std::string SerializeEvalAutomorphismKeyToStringWrapper(const ST& sertype, const
 }
 
 template <typename ST>
-py::bytes SerializeEvalAutomorphismKeyToBytesWrapper(const ST& sertype, const std::string& id) {
+py::bytes SerializeEvalAutomorphismKeyToBytesWrapper(const ST& sertype, const std::string& keyTag) {
     // let strbuf be dynamically allocated as we may be dealing with large keys
     auto strbuf = std::make_unique<std::stringbuf>(std::ios::out | std::ios::binary);
     std::ostream oss(strbuf.get());
 
-    if (!CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey(oss, sertype, id)) {
+    if (!CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey(oss, sertype, keyTag)) {
         throw std::runtime_error("Failed to serialize EvalAutomorphismKey");
     }
 
@@ -210,7 +210,7 @@ void DeserializeEvalMultKeyFromBytesWrapper(const py::bytes& bytes, const ST& se
 template <typename ST>
 void DeserializeEvalAutomorphismKeyFromStringWrapper(const std::string& data, const ST& sertype) {
     std::istringstream iss(data);
-    std::map<std::string, std::shared_ptr<std::map<usint, EvalKey<DCRTPoly>>>> keyMap;
+    std::map<std::string, std::shared_ptr<std::map<uint32_t, EvalKey<DCRTPoly>>>> keyMap;
     bool res = CryptoContextImpl<DCRTPoly>::DeserializeEvalAutomorphismKey<ST>(iss, sertype);
     if (!res) {
         throw std::runtime_error("Failed to deserialize EvalAutomorphismKey");
@@ -281,12 +281,12 @@ void bind_serialization(pybind11::module &m) {
           py::arg("str"), py::arg("sertype"));
 
     m.def("SerializeEvalMultKeyString", &SerializeEvalMultKeyToStringWrapper<SerType::SERJSON>,
-          py::arg("sertype"), py::arg("id") = "");
+          py::arg("sertype"), py::arg("keyTag") = "");
     m.def("DeserializeEvalMultKeyString",
           static_cast<void (*)(const std::string&, const SerType::SERJSON&)>(&DeserializeEvalMultKeyFromStringWrapper<SerType::SERJSON>),
           py::arg("data"), py::arg("sertype"));
     m.def("SerializeEvalAutomorphismKeyString", &SerializeEvalAutomorphismKeyToStringWrapper<SerType::SERJSON>,
-          py::arg("sertype"), py::arg("id") = "");
+          py::arg("sertype"), py::arg("keyTag") = "");
     m.def("DeserializeEvalAutomorphismKeyString",
           static_cast<void (*)(const std::string&, const SerType::SERJSON&)>(&DeserializeEvalAutomorphismKeyFromStringWrapper<SerType::SERJSON>),
           py::arg("data"), py::arg("sertype"));
@@ -348,12 +348,12 @@ void bind_serialization(pybind11::module &m) {
           py::arg("str"), py::arg("sertype"));
 
     m.def("SerializeEvalMultKeyString", &SerializeEvalMultKeyToBytesWrapper<SerType::SERBINARY>,
-          py::arg("sertype"), py::arg("id") = "");
+          py::arg("sertype"), py::arg("keyTag") = "");
     m.def("DeserializeEvalMultKeyString",
           static_cast<void (*)(const py::bytes&, const SerType::SERBINARY&)>(&DeserializeEvalMultKeyFromBytesWrapper<SerType::SERBINARY>),
           py::arg("bytes"), py::arg("sertype"));
     m.def("SerializeEvalAutomorphismKeyString", &SerializeEvalAutomorphismKeyToBytesWrapper<SerType::SERBINARY>,
-          py::arg("sertype"), py::arg("id") = "");
+          py::arg("sertype"), py::arg("keyTag") = "");
     m.def("DeserializeEvalAutomorphismKeyString",
           static_cast<void (*)(const py::bytes&, const SerType::SERBINARY&)>(&DeserializeEvalAutomorphismKeyFromBytesWrapper<SerType::SERBINARY>),
           py::arg("bytes"), py::arg("sertype"));