diff --git a/README.md b/README.md
index a9f527c85..bf50e1802 100644
--- a/README.md
+++ b/README.md
@@ -17,17 +17,12 @@ Source code adapted from [C++ source code published here](https://www.sanfoundry
 
 1) Install the OpenFHE library on your machine by following the [official documentation](https://openfhe-development.readthedocs.io/en/latest/sphinx_rsts/intro/installation/installation.html). Do note that the following example has not been tested on windows or macOS.
 
-2) Clone this repo to your local system and `cd` into it
-
-```
-git clone git@github.com:openfheorg/openfhe-integer-examples.git
-cd openfhe-integer-examples
-```
+2) Clone this repo to your local system
 
 3) Build this code
 
 ```
-mkdir build
+mkdr build
 cd build 
 cmake ..
 make 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 4bfa92a53..1ec9767f4 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,2 +1,2 @@
 add_executable( strsearch_enc_1 strsearch_enc_1.cpp)
-add_executable( strsearch_enc_2 strsearch_enc_2.cpp )
+add_executable( strsearch_enc_2 strsearch_enc_2.cpp)
diff --git a/src/strsearch_enc_1.cpp b/src/strsearch_enc_1.cpp
index 5fc4233fa..0a2d38e7e 100644
--- a/src/strsearch_enc_1.cpp
+++ b/src/strsearch_enc_1.cpp
@@ -1,4 +1,4 @@
-/* OpenFHE C++ program implements the Rabin-Karp method for string
+/* PALISADE C++ program implements the Rabin-Karp method for string
  * matching using encrypted computation and no SIMD batching
  * plaintext version of this code comes from
  * https://www.sanfoundry.com/cpp-program-implement-rabin-karp-method-for-string-matching
@@ -6,18 +6,17 @@
  */
 
 
-#include <cstring>
+#include <stdio.h>
+#include <string.h>
 #include <iostream>
+#include <fstream>
 #include <vector>
 #include "openfhe.h"
-#include "scheme/bfvrns/cryptocontext-bfvrns.h"
-#include "gen-cryptocontext.h"
-#include "utils/debug.h"
 using namespace std;
 
 //data types we will need
-using CT = lbcrypto::Ciphertext<lbcrypto::DCRTPoly> ; //ciphertext
-using PT = lbcrypto::Plaintext ; //plaintext
+using CT = lbcrypto::Ciphertext<lbcrypto::DCRTPoly>; //ciphertext
+using PT = lbcrypto::Plaintext; //plaintext
 using vecCT = vector<CT>; //vector of ciphertexts
 using vecPT = vector<PT>; //vector of plaintexts
 using vecInt = vector<int64_t>; // vector of ints
@@ -31,33 +30,33 @@ const int d = 256;
 //	p    -> A prime number
 
 // function to get string input from terminal and return as vector of char
-void get_input_from_term(vecChar& a) {
+void get_input_from_term(vecChar &a) {
   string cstr;
-  cin.ignore(numeric_limits<streamsize>::max(),'\n'); //flushes buffer
+  cin.ignore(numeric_limits<streamsize>::max(), '\n'); //flushes buffer
   std::getline(std::cin, cstr);
-  cout <<"Pattern is `"<<cstr<<"'"<<endl;
-  for(auto c: cstr) {
-	  a.push_back(c);
+  cout << "Pattern is `" << cstr << "'" << endl;
+  for (auto c : cstr) {
+    a.push_back(c);
   }
-  cout <<"Pattern is "<<a.size()<<" characters"<<endl;
+  cout << "Pattern is " << a.size() << " characters" << endl;
   return;
 }
 
 // function to read text from a file and return as vector of char
-void get_input_from_file(vecChar& a, string fname) {
+void get_input_from_file(vecChar &a, string fname) {
   char c;
 
   ifstream in_file;
   in_file.open(fname);
   if (!in_file) {
-    cerr << "Can't open file for input: "<<fname;
+    cerr << "Can't open file for input: " << fname;
     exit(-1); //error exit
   }
 
   while (in_file >> c) {
-	  a.push_back(c);
+    a.push_back(c);
   }
-  cout <<"Read "<<a.size()<<" characters"<<endl;
+  cout << "Read " << a.size() << " characters" << endl;
   in_file.close();
   return;
 }
@@ -78,83 +77,83 @@ vecInt search(vecChar &pat, vecChar &txt, int ps) {
   size_t nfound = 0;
 
   // The value of h would be "pow(d, M-1)%p"
-  for (i = 0; i < M-1; i++) {
-    h = (h*d)%p;
+  for (i = 0; i < M - 1; i++) {
+    h = (h * d) % p;
     OPENFHE_DEBUGEXP(h);
   }
-  OPENFHE_DEBUG(" hfinal: "<<h);
+  OPENFHE_DEBUG(" hfinal: " << h);
 
   // Calculate the hash value of pattern and first window of text
   for (i = 0; i < M; i++) {
     ph = (d * ph + pat[i]) % p;
     th = (d * th + txt[i]) % p;
   }
-  OPENFHE_DEBUG(" initial ph: "<<ph);
-  OPENFHE_DEBUG(" initial th: "<<th);
+  OPENFHE_DEBUG(" initial ph: " << ph);
+  OPENFHE_DEBUG(" initial th: " << th);
   vecInt pres(0);
   // Slide the pattern over text one by one
   for (i = 0; i <= N - M; i++) {
 
     // Check the hash values of current window of text and pattern
     // If the hash values match then only check for characters on by one
-    pres.push_back((ph-th)%p);
-    if ( ph == th )	{
+    pres.push_back((ph - th) % p);
+    if (ph == th) {
       /* Check for characters one by one */
       for (j = 0; j < M; j++) {
-      if (txt[i + j] != pat[j])
-        break;
+        if (txt[i + j] != pat[j])
+          break;
       }
       if (j == M) { // if ph == t and pat[0...M-1] = txt[i, i+1, ...i+M-1]
 
-      cout<<"Pattern found at index "<< i << endl;
-      nfound++;
+        cout << "Pattern found at index " << i << endl;
+        nfound++;
       }
     }
 
     // Calculate hash value for next window of text: Remove leading digit,
     // add trailing digit
-    if ( i < N - M ) {
+    if (i < N - M) {
       th = (d * (th - txt[i] * h) + txt[i + M]) % p;
 
       // We might get negative value of t, converting it to positive
       if (th < 0) {
-      th = (th + p);
+        th = (th + p);
       }
 
     }
   } //end for
 
-  cout<<"total occurances " <<nfound<<endl;
+  cout << "total occurances " << nfound << endl;
   return pres;
 }
 
 // helper function to encrypt an integer repeatedly into a packed plaintext
 // and encrypt it
-CT encrypt_repeated_integer(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc, lbcrypto::PublicKey<lbcrypto::DCRTPoly> &pk,  int64_t in, size_t n){
+CT encrypt_repeated_integer(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc, lbcrypto::PublicKey<lbcrypto::DCRTPoly> &pk, int64_t in, size_t n) {
 
   vecInt v_in(n, in);
-  PT pt= cc->MakePackedPlaintext(v_in);
+  PT pt = cc->MakePackedPlaintext(v_in);
   CT ct = cc->Encrypt(pk, pt);
 
   return ct;
 }
 
 // helper function to multiply by constant 256 using binary tree addition
-CT encMultD(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc, CT in){
-  if (d !=256){
-    cout <<"error d not 256"<<endl;
+CT encMultD(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc, CT in) {
+  if (d != 256) {
+    cout << "error d not 256" << endl;
     exit(-1);
   }
   auto tmp(in);
-  for (auto i = 0; i< 8; i++ ){
-	  tmp = cc->EvalAdd(tmp, tmp);
+  for (auto i = 0; i < 8; i++) {
+    tmp = cc->EvalAdd(tmp, tmp);
   }
 
-  return(tmp);
+  return (tmp);
 }
 
 //Single value encrypted search
-vecCT encrypted_search(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc,  lbcrypto::PublicKey<lbcrypto::DCRTPoly> &pk, vecCT &epat, vecCT &etxt, int ps) {
+vecCT encrypted_search(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc, lbcrypto::PublicKey<lbcrypto::DCRTPoly> &pk, vecCT &epat, vecCT &etxt, int ps) {
 
   int64_t p(ps);
   OPENFHE_DEBUG_FLAG(false);
@@ -174,12 +173,12 @@ vecCT encrypted_search(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc,  lbcrypt
   OPENFHE_DEBUG("encrypting hct");
   // The value of h would be "pow(d, M-1)%p"
   int64_t h = 1;
-  for (i = 0; i < M-1; i++) {
-	  h = (h*d)%p;
+  for (i = 0; i < M - 1; i++) {
+    h = (h * d) % p;
   }
   CT hct = encrypt_repeated_integer(cc, pk, h, nrep);  // encrypted h
 
-  OPENFHE_DEBUG("encrypting first hashes" );
+  OPENFHE_DEBUG("encrypting first hashes");
   // Calculate the hash value of pattern and first window of text
   for (i = 0; i < M; i++) {
     auto tmp = encMultD(cc, phct);
@@ -191,37 +190,36 @@ vecCT encrypted_search(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc,  lbcrypt
 
   vecCT eres(0);
   // Slide the pattern over text one by one
-  OPENFHE_DEBUG("sliding" );
+  OPENFHE_DEBUG("sliding");
   for (i = 0; i <= N - M; i++) {
-	cout<<i<< '\r'<<flush;
+    cout << i << '\r' << flush;
 
-	// Check the hash values of current window of text and pattern
-	// If the hash values match then only check for characters on by one
-	// subtract the two hashes, zero is equality
-	OPENFHE_DEBUG("sub" );
-	eres.push_back(cc->EvalSub(phct, thct));
+    // Check the hash values of current window of text and pattern
+    // If the hash values match then only check for characters on by one
+    // subtract the two hashes, zero is equality
+    OPENFHE_DEBUG("sub");
+    eres.push_back(cc->EvalSub(phct, thct));
 
-	// Calculate hash value for next window of text: Remove leading digit,
-	// add trailing digit
-	if ( i < N - M ) {
-	  OPENFHE_DEBUG("rehash" );
-	  //th = (d * (th - txt[i] * h) + txt[i + M]) % p;
+    // Calculate hash value for next window of text: Remove leading digit,
+    // add trailing digit
+    if (i < N - M) {
+      OPENFHE_DEBUG("rehash");
+      //th = (d * (th - txt[i] * h) + txt[i + M]) % p;
 
-	  auto tmp = encMultD(cc,
-						  cc->EvalSub(thct,
-									  cc->EvalMult(etxt[i], hct)
-									  )
-						  );
-	  thct = cc->EvalAdd(tmp, etxt[i+M] );
+      auto tmp = encMultD(cc,
+                          cc->EvalSub(thct,
+                                      cc->EvalMult(etxt[i], hct)
+                          )
+      );
+      thct = cc->EvalAdd(tmp, etxt[i + M]);
 
-	}
+    }
 
   } //end for
   return eres;
 }
 
-int main()
-{
+int main() {
   vecChar bigtxt;
 
   vecChar pat;
@@ -238,11 +236,11 @@ int main()
   //cin>> textSize;
   textSize = 32;
   uint32_t offset(16);
-  cout << "Limiting search to "<<textSize<< " characters "
-	  <<"starting at offset "<<offset<<endl;
+  cout << "Limiting search to " << textSize << " characters "
+       << "starting at offset " << offset << endl;
 
   vecChar::const_iterator first = bigtxt.begin() + offset;
-  vecChar::const_iterator last = bigtxt.begin() + offset+textSize;
+  vecChar::const_iterator last = bigtxt.begin() + offset + textSize;
   vecChar txt(first, last);
 
   //Note inputs are hardwired, uncomment to add user control
@@ -253,43 +251,33 @@ int main()
   int p = 786433; //plaintext prime modulus
   //int p = 65537; //note this causes exception
 
-  cout<<"p "<<p<<endl;
+  cout << "p " << p << endl;
   TIC(auto t1);
 
   auto presult = search(pat, txt, p);
   auto plain_time_ms = TOC_MS(t1);
-  cout<< "Plaintext execution time "<<plain_time_ms<<" mSec."<<endl;
+  cout << "Plaintext execution time " << plain_time_ms << " mSec." << endl;
 
-  cout <<"setting up BFV RNS crypto system"<<endl;
+  cout << "setting up BFV RNS crypto system" << endl;
 
   uint32_t plaintextModulus = p;
   uint32_t multDepth = 32;
 
-  double sigma = 3.2;
   lbcrypto::SecurityLevel securityLevel = lbcrypto::HEStd_128_classic;
 
-    /**
-     * Old implementation:
-      lbcrypto::CryptoContextFactory<lbcrypto::DCRTPoly>::genCryptoContextBFVrns(
-          plaintextModulus, securityLevel, sigma, 0, multDepth, 0, OPTIMIZED);
-     */
-  lbcrypto::CCParams<lbcrypto::CryptoContextBFVRNS> parameters;
-    parameters.SetPlaintextModulus(plaintextModulus);
-    parameters.SetSecurityLevel(securityLevel);
-    parameters.SetStandardDeviation(sigma);
-    parameters.SetMultiplicativeDepth(multDepth);
-
-    lbcrypto::CryptoContext<lbcrypto::DCRTPoly> cc = lbcrypto::GenCryptoContext(parameters);
-
-    // Instantiate the crypto context
+  lbcrypto::CCParams<lbcrypto::CryptoContextBFVRNS> params;
+  params.SetPlaintextModulus(plaintextModulus);
+  params.SetSecurityLevel(securityLevel);
+  params.SetMultiplicativeDepth(multDepth);
+  params.SetSecretKeyDist(UNIFORM_TERNARY);
+  auto cc = GenCryptoContext(params);
 
 
   // Enable features that you wish to use
-    cc->Enable(PKE);
-    cc->Enable(KEYSWITCH);
-    cc->Enable(LEVELEDSHE);
+  cc->Enable(PKE);
+  cc->Enable(LEVELEDSHE);
 
-    cout<<"Step 2 - Key Generation"<<endl;
+  cout << "Step 2 - Key Generation" << endl;
 
   // Initialize Public Key Containers
   // Generate a public/private key pair
@@ -298,18 +286,18 @@ int main()
   // Generate the relinearization key
   cc->EvalMultKeyGen(keyPair.secretKey);
 
-  cout<<"Step 3 - Encryption"<<endl;
+  cout << "Step 3 - Encryption" << endl;
 
-  cout<<"Step 3.1 - Encrypt pattern"<<endl;
+  cout << "Step 3.1 - Encrypt pattern" << endl;
   //encrypt the pattern
   vecInt vin(0);
   vecCT epat(0);
   uint32_t j(0);
-  for (auto ch: pat) {
-    cout<<j<< '\r'<<flush;
+  for (auto ch : pat) {
+    cout << j << '\r' << flush;
     j++;
     vin.push_back(ch);
-    PT pt= cc->MakePackedPlaintext(vin);
+    PT pt = cc->MakePackedPlaintext(vin);
     vin.clear();
     CT ct = cc->Encrypt(keyPair.publicKey, pt);
     epat.push_back(ct);
@@ -317,35 +305,35 @@ int main()
 
   //encrypt the text
   auto ringsize = cc->GetRingDimension();
-  cout << "ringsize = "<<ringsize << endl;
-  cout << "txt size = "<<txt.size() << endl;
-  uint32_t nbatch = int(ceil(float(txt.size())/float(ringsize)));
-  cout << "can store "<<nbatch <<" batches in the ct"<<endl;
+  cout << "ringsize = " << ringsize << endl;
+  cout << "txt size = " << txt.size() << endl;
+  uint32_t nbatch = int(ceil(float(txt.size()) / float(ringsize)));
+  cout << "can store " << nbatch << " batches in the ct" << endl;
 
-  cout<<"Step 3.2 - Encrypt text"<<endl;
+  cout << "Step 3.2 - Encrypt text" << endl;
   vecCT etxt(0);
   auto pt_len(0);
   for (usint i = 0; i < txt.size(); i++) {
-    cout<<i<< '\r'<<flush;
+    cout << i << '\r' << flush;
 
     vin.push_back(txt[i]);
-    lbcrypto::Plaintext pt= cc->MakePackedPlaintext(vin);
+    lbcrypto::Plaintext pt = cc->MakePackedPlaintext(vin);
     pt_len = pt->GetLength();
     vin.clear();
     CT ct = cc->Encrypt(keyPair.publicKey, pt);
     etxt.push_back(ct);
   }
-  cout<<"Step 4 - Encrypted string search"<<endl;
+  cout << "Step 4 - Encrypted string search" << endl;
 
   TIC(auto t2);
 
   vecCT eresult = encrypted_search(cc, keyPair.publicKey, epat, etxt, p);
   auto encrypted_time_ms = TOC_MS(t2);
-  cout<< "Encrypted execution time "<<encrypted_time_ms<<" mSec."<<endl;
+  cout << "Encrypted execution time " << encrypted_time_ms << " mSec." << endl;
 
   //decrypt the result and compute location of potential matches
   vecPT vecResult(0);
-  for (auto e_itr:eresult){
+  for (auto e_itr : eresult) {
     PT ptresult;
     cc->Decrypt(keyPair.secretKey, e_itr, &ptresult);
     ptresult->SetLength(pt_len);
@@ -354,15 +342,15 @@ int main()
 
   int i(0);
   int nfound(0);
-  for (auto val: vecResult) {
+  for (auto val : vecResult) {
     auto unpackedVal = val->GetPackedValue();
     if (unpackedVal[0] == 0) {
-      cout<<"Pattern found at index "<< i << endl;
+      cout << "Pattern found at index " << i << endl;
       nfound++;
     }
     i++;
   }
-  cout<<"total occurances "<<nfound<<endl;
+  cout << "total occurances " << nfound << endl;
 
   return 0;
 }
diff --git a/src/strsearch_enc_2.cpp b/src/strsearch_enc_2.cpp
index f1bb84783..3d4235e6e 100644
--- a/src/strsearch_enc_2.cpp
+++ b/src/strsearch_enc_2.cpp
@@ -1,35 +1,31 @@
-/* OpenFHE C++ program implements the Rabin-Karp method for string
+/* PALISADE C++ program implements the Rabin-Karp method for string
  * matching using encrypted computation with SIMD batching
- * plaintext version of this code comes from 
+ * plaintext version of this code comes from
  * https://www.sanfoundry.com/cpp-program-implement-rabin-karp-method-for-string-matching
  * author David Bruce Cousins@dualitytech.com
 
  */
 
-
-#include <cstring>
+#include <stdio.h>
+#include <string.h>
 #include <iostream>
+#include <fstream>
 #include <vector>
 #include <algorithm>
-
 #include "openfhe.h"
-#include "utils/debug.h"
-#include "scheme/bfvrns/cryptocontext-bfvrns.h"
-#include "gen-cryptocontext.h"
 using namespace std;
-using namespace lbcrypto;
 
 //data types we will need
-using CT = Ciphertext<DCRTPoly> ; //ciphertext
-using PT = Plaintext ; //plaintext
+using CT = lbcrypto::Ciphertext<lbcrypto::DCRTPoly>; //ciphertext
+using PT = lbcrypto::Plaintext; //plaintext
 using vecCT = vector<CT>; //vector of ciphertexts
 using vecPT = vector<PT>; //vector of plaintexts
 using vecInt = vector<int64_t>; // vector of ints
 using vecChar = vector<char>; // vector of characters
 
 // d is the number of characters in input alphabet
-const int32_t d = 256; 
-     
+const int32_t d = 256;
+
 /*  pat  -> pattern
 	txt  -> text
 	p    -> A prime number
@@ -37,39 +33,39 @@ const int32_t d = 256;
 
 
 // function to get string input from terminal and return as vector of char
-void get_input_from_term(vecChar& a) {
+void get_input_from_term(vecChar &a) {
   string cstr;
-  cin.ignore(numeric_limits<streamsize>::max(),'\n'); //flushes buffer
+  cin.ignore(numeric_limits<streamsize>::max(), '\n'); //flushes buffer
   cin >> ws; //discards white space
   std::getline(std::cin, cstr);
-  cout <<"Pattern is `"<<cstr<<"'"<<endl;    
-  for(auto c: cstr) {
-	  a.push_back(c);
+  cout << "Pattern is `" << cstr << "'" << endl;
+  for (auto c : cstr) {
+    a.push_back(c);
   }
-  cout <<"Pattern is "<<a.size()<<" characters"<<endl;  
+  cout << "Pattern is " << a.size() << " characters" << endl;
   return;
 }
 
 // function to read text from a file and return as vector of char
-void get_input_from_file(vecChar& a, string fname) {
+void get_input_from_file(vecChar &a, string fname) {
   char c;
 
   ifstream in_file;
   in_file.open(fname);
   if (!in_file) {
-    cerr << "Can't open file for input: "<<fname<<endl;
+    cerr << "Can't open file for input: " << fname << endl;
     exit(-1); //error exit
   }
-  
+
   while (in_file >> c) {
-	a.push_back(c);
+    a.push_back(c);
   }
-  cout <<"Read "<<a.size()<<" characters"<<endl;
+  cout << "Read " << a.size() << " characters" << endl;
   in_file.close();
   return;
 }
-     
-// plaintext string search of pat within txt, with modulus of ps     
+
+// plaintext string search of pat within txt, with modulus of ps
 vecInt search(vecChar &pat, vecChar &txt, int ps) {
   int64_t p(ps);
   OPENFHE_DEBUG_FLAG(false);
@@ -83,86 +79,86 @@ vecInt search(vecChar &pat, vecChar &txt, int ps) {
   int64_t h = 1;
 
   int nfound = 0;
-     
+
   // The value of h would be "pow(d, M-1)%p"
-  for (i = 0; i < M-1; i++) {
-    h = (h*d)%p;
+  for (i = 0; i < M - 1; i++) {
+    h = (h * d) % p;
     OPENFHE_DEBUGEXP(h);
   }
-  OPENFHE_DEBUG(" hfinal: "<<h);
+  OPENFHE_DEBUG(" hfinal: " << h);
 
   // Calculate the hash value of pattern and first window of text
   for (i = 0; i < M; i++) {
     ph = (d * ph + pat[i]) % p;
     th = (d * th + txt[i]) % p;
   }
-  OPENFHE_DEBUG(" initial ph: "<<ph);
-  OPENFHE_DEBUG(" initial th: "<<th);
+ OPENFHE_DEBUG(" initial ph: " << ph);
+ OPENFHE_DEBUG(" initial th: " << th);
   vecInt pres(0);
   // Slide the pattern over text one by one
   for (i = 0; i <= N - M; i++) {
-	
-	// Check the hash values of current window of text and pattern
-	// If the hash values match then only check for characters on by one
-	if ( ph == th )	{
-	  /* Check for characters one by one */
-	  for (j = 0; j < M; j++) {
-		if (txt[i + j] != pat[j])
-		  break;
-	  }
-	  if (j == M) { // if ph == t and pat[0...M-1] = txt[i, i+1, ...i+M-1]
-
-		//cout<<"Pattern found at index "<< i << endl;
-		pres.push_back(i);
-		nfound++;
-	  }
-	}
-     
-	// Calculate hash value for next window of text: Remove leading digit,
-	// add trailing digit
-	if ( i < N - M ) {
-	  th = (d * (th - txt[i] * h) + txt[i + M]) % p;
-
-	  // We might get negative value of t, converting it to positive
-	  if (th < 0) {
-		th = (th + p);
-	  }
-
-	  //cout<<" "<<th;
-	}
+
+    // Check the hash values of current window of text and pattern
+    // If the hash values match then only check for characters on by one
+    if (ph == th) {
+      /* Check for characters one by one */
+      for (j = 0; j < M; j++) {
+        if (txt[i + j] != pat[j])
+          break;
+      }
+      if (j == M) { // if ph == t and pat[0...M-1] = txt[i, i+1, ...i+M-1]
+
+        //cout<<"Pattern found at index "<< i << endl;
+        pres.push_back(i);
+        nfound++;
+      }
+    }
+
+    // Calculate hash value for next window of text: Remove leading digit,
+    // add trailing digit
+    if (i < N - M) {
+      th = (d * (th - txt[i] * h) + txt[i + M]) % p;
+
+      // We might get negative value of t, converting it to positive
+      if (th < 0) {
+        th = (th + p);
+      }
+
+      //cout<<" "<<th;
+    }
   } //end for
   //cout<<endl;
-  cout<<"total occurences " <<nfound<<endl;
+  cout << "total occurences " << nfound << endl;
   return pres;
 }
-     
+
 // helper function to encrypt an integer repeatedly into a packed plaintext
 // and encrypt it
-CT encrypt_repeated_integer(CryptoContext<DCRTPoly> &cc, PublicKey<DCRTPoly> &pk,  int64_t in, size_t n){
-  
+CT encrypt_repeated_integer(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc, lbcrypto::PublicKey<lbcrypto::DCRTPoly> &pk, int64_t in, size_t n) {
+
   vecInt v_in(n, in);
-  PT pt= cc->MakePackedPlaintext(v_in);
+  PT pt = cc->MakePackedPlaintext(v_in);
   CT ct = cc->Encrypt(pk, pt);
 
   return ct;
 }
 
 // helper function to multiply by constant 256 using binary tree addition
-CT encMultD(CryptoContext<DCRTPoly> &cc, CT in){
-  if (d !=256){
-	cout <<"error d not 256"<<endl;
-	exit(-1);
+CT encMultD(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc, CT in) {
+  if (d != 256) {
+    cout << "error d not 256" << endl;
+    exit(-1);
   }
   auto tmp(in);
-  for (size_t i = 0; i< 8; i++ ){
-	  tmp = cc->EvalAdd(tmp, tmp);
+  for (size_t i = 0; i < 8; i++) {
+    tmp = cc->EvalAdd(tmp, tmp);
   }
-  
-  return(tmp);
+
+  return (tmp);
 }
 
 //SIMD encrypted search
-vecCT encrypted_search(CryptoContext<DCRTPoly> &cc,  PublicKey<DCRTPoly> &pk,  vecCT &epat, vecCT &etxt, int ps) {
+vecCT encrypted_search(lbcrypto::CryptoContext<lbcrypto::DCRTPoly> &cc, lbcrypto::PublicKey<lbcrypto::DCRTPoly> &pk, vecCT &epat, vecCT &etxt, int ps) {
 
   int64_t p(ps);
   OPENFHE_DEBUG_FLAG(false);
@@ -173,26 +169,26 @@ vecCT encrypted_search(CryptoContext<DCRTPoly> &cc,  PublicKey<DCRTPoly> &pk,  v
   size_t i;
 
   PT dummy;
-  
+
   size_t nrep(cc->GetRingDimension());
-  OPENFHE_DEBUG("encrypting small ct");
+ OPENFHE_DEBUG("encrypting small ct");
   CT phct = encrypt_repeated_integer(cc, pk, 0, nrep);  // hash value for pattern
   CT thct = encrypt_repeated_integer(cc, pk, 0, nrep);  // hash value for txt
 
   CT dhct = encrypt_repeated_integer(cc, pk, d, nrep);  // d
 
-  OPENFHE_DEBUG("encrypting hct");
+ OPENFHE_DEBUG("encrypting hct");
   // The value of h would be "pow(d, M-1)%p"
   long h = 1;
-  for (i = 0; i < M-1; i++) {
-	  h = (h*d)%p;
+  for (i = 0; i < M - 1; i++) {
+    h = (h * d) % p;
   }
   CT hct = encrypt_repeated_integer(cc, pk, h, nrep);  // encrypted h
 
-  OPENFHE_DEBUG("encrypting first hashes" );
+ OPENFHE_DEBUG("encrypting first hashes");
   // Calculate the hash value of pattern and first window of text
   for (i = 0; i < M; i++) {
-    auto tmp = encMultD(cc, phct);	
+    auto tmp = encMultD(cc, phct);
     phct = cc->EvalAdd(tmp, epat[i]);
 
     tmp = encMultD(cc, thct);
@@ -201,36 +197,35 @@ vecCT encrypted_search(CryptoContext<DCRTPoly> &cc,  PublicKey<DCRTPoly> &pk,  v
 
   vecCT eres(0);
   // Slide the pattern over text one by one
-  OPENFHE_DEBUG("sliding" );
+ OPENFHE_DEBUG("sliding");
   for (i = 0; i <= N - M; i++) {
-    cout<<i<< '\r'<<flush;
-    
+    cout << i << '\r' << flush;
+
     // Check the hash values of current window of text and pattern
     // If the hash values match then only check for characters on by one
     // subtract the two hashes, zero is equality
-    OPENFHE_DEBUG("sub" );
+   OPENFHE_DEBUG("sub");
     eres.push_back(cc->EvalSub(phct, thct));
-      
+
     // Calculate hash value for next window of text: Remove leading digit,
     // add trailing digit
-    if ( i < N - M ) {
-      OPENFHE_DEBUG("rehash" );
+    if (i < N - M) {
+     OPENFHE_DEBUG("rehash");
       //th = (d * (th - txt[i] * h) + txt[i + M]) % p;
       auto tmp = encMultD(cc,
-                cc->EvalSub(thct,
-                      cc->EvalMult(etxt[i], hct)
-                      )
-                );
+                          cc->EvalSub(thct,
+                                      cc->EvalMult(etxt[i], hct)
+                          )
+      );
 
-      thct = cc->EvalAdd(tmp, etxt[i+M] );
+      thct = cc->EvalAdd(tmp, etxt[i + M]);
     }
 
   } //end for
   return eres;
 }
-     
-int main()
-{
+
+int main() {
   vecChar txt;
   vecChar pat;
   string infilename;
@@ -246,200 +241,198 @@ int main()
   //cin>> maxNBatches;
   maxNBatches = 32;
   minNBatches = 10;
-  cout << "batching to "<<maxNBatches<< " characters max"<<endl;
+  cout << "batching to " << maxNBatches << " characters max" << endl;
 
   //cout<<"Enter Pattern to Search:";
-  
+
   //get_input_from_term(pat);
   pat = {'A', 'n', 'n', 'a'};
 
   int32_t p = 786433; //plaintext prime modulus
   //int p = 65537; // use this to show core dump
 
-  cout<<"p "<<p<<endl;
-  TIC(auto t1);
+  cout << "p " << p << endl;
+  TIC(auto
+  t1);
 
   auto presult = search(pat, txt, p);
   auto plain_time_ms = TOC_MS(t1);
-  cout<< "Plaintext execution time "<<plain_time_ms<<" mSec."<<endl;
+  cout << "Plaintext execution time " << plain_time_ms << " mSec." << endl;
 
-  cout <<"setting up BFV RNS crypto system"<<endl;
+  cout << "setting up BFV RNS crypto system" << endl;
 
   uint32_t plaintextModulus = p;
   uint32_t multDepth = 32; //works for 32 batches
 
-  double sigma = 3.2;
-  SecurityLevel securityLevel = HEStd_128_classic;
+  lbcrypto::SecurityLevel securityLevel = lbcrypto::HEStd_128_classic;
 
-  lbcrypto::CCParams<lbcrypto::CryptoContextBFVRNS> parameters;
-  parameters.SetPlaintextModulus(plaintextModulus);
-  parameters.SetSecurityLevel(securityLevel);
-  parameters.SetStandardDeviation(sigma);
-  parameters.SetMultiplicativeDepth(multDepth);
 
-  lbcrypto::CryptoContext<lbcrypto::DCRTPoly > cc = lbcrypto::GenCryptoContext(parameters);
+  lbcrypto::CCParams<lbcrypto::CryptoContextBFVRNS> params;
+  params.SetPlaintextModulus(plaintextModulus);
+  params.SetSecurityLevel(securityLevel);
+  params.SetMultiplicativeDepth(multDepth);
+  params.SetSecretKeyDist(UNIFORM_TERNARY);
+  auto cc = GenCryptoContext(params);
 
-    cc->Enable(PKE);
-    cc->Enable(KEYSWITCH);
-    cc->Enable(LEVELEDSHE);
+  cc->Enable(PKE);
+  cc->Enable(LEVELEDSHE);
 
+  cout << "Step 2 - Key Generation" << endl;
 
-  cout<<"Step 2 - Key Generation"<<endl;
-  
   // Initialize Public Key Containers
   // Generate a public/private key pair
   auto keyPair = cc->KeyGen();
-  
+
   // Generate the relinearization key
   cc->EvalMultKeyGen(keyPair.secretKey);
 
   // note we do not use rotation in this example so we don't need rotation keys
-  // but make them anyway 
+  // but make them anyway
   // Generate the rotation evaluation keys
-  //cc->EvalAtIndexKeyGen(keyPair.secretKey, {1, 2, -1, -2}); 
+  //cc->EvalAtIndexKeyGen(keyPair.secretKey, {1, 2, -1, -2});
 
-  cout<<"Step 3 - Encryption"<<endl;  
+  cout << "Step 3 - Encryption" << endl;
 
-  cout<<"Step 3.1 - Encrypt text"<<endl;  
+  cout << "Step 3.1 - Encrypt text" << endl;
 
   //encrypt the text
   auto ringsize = cc->GetRingDimension();
-  cout << "Given ringsize = "<<ringsize << endl;
-  cout << "and text size = "<<txt.size() << endl;
-  uint32_t nbatchEst = int(ceil(float(txt.size())/float(ringsize)));
-  cout << "We can store approximately "<<nbatchEst <<" batches in the CT"<<endl;
+  cout << "Given ringsize = " << ringsize << endl;
+  cout << "and text size = " << txt.size() << endl;
+  uint32_t nbatchEst = int(ceil(float(txt.size()) / float(ringsize)));
+  cout << "We can store approximately " << nbatchEst << " batches in the CT" << endl;
 
   //need to encrypt the text in batches, each one consists of
-  //nbatch points. the next batch starts at nbatch-M 
+  //nbatch points. the next batch starts at nbatch-M
   //so each CT in the vecCT has ringsize entries.
   // vecCT[0] has characters {0, nbatch-M, 2(nbatch-M) etc..}
   // vecCT[1] has characters {1, 1+(nbatch-M), 1+2(nbatch-M) etc..}
-  cout << "Adjusting number of batches to account for pattern overlap"<<endl;
+  cout << "Adjusting number of batches to account for pattern overlap" << endl;
   bool done(false);
   auto nbatch = max(minNBatches, nbatchEst);
   auto M(pat.size());
 
   //offset into text corresponding to start of each ring element
-  vecInt offset(0); 
+  vecInt offset(0);
   size_t largestIx(0);
-  while (!done){
+  while (!done) {
     //try this combination of nbatch and M and adjust till it fits
     offset.clear();
-    for(size_t bat = 0; bat < ringsize; bat++){
-      offset.push_back(bat*(nbatch-M+1));
+    for (size_t bat = 0; bat < ringsize; bat++) {
+      offset.push_back(bat * (nbatch - M + 1));
     }
 
-    largestIx= offset[offset.size()-1]+(nbatch-1);
+    largestIx = offset[offset.size() - 1] + (nbatch - 1);
 
-    if (largestIx >= txt.size()){
+    if (largestIx >= txt.size()) {
       done = true;
     } else {
       nbatch++;
-      cout<<"increasing batch size to "<<nbatch<<endl;
+      cout << "increasing batch size to " << nbatch << endl;
     }
   }
 
-  
   if (nbatch > maxNBatches) {
-	cout<<"have to limit number of batches to "<<maxNBatches<<endl;
-	nbatch = maxNBatches;
-	if (largestIx+1 < txt.size()){
-	  cout<<"have to limit text size to "<<largestIx+1<<endl;
-	  txt.resize(largestIx+1);
-	}
+    cout << "have to limit number of batches to " << maxNBatches << endl;
+    nbatch = maxNBatches;
+    if (largestIx + 1 < txt.size()) {
+      cout << "have to limit text size to " << largestIx + 1 << endl;
+      txt.resize(largestIx + 1);
+    }
   }
 
   vecCT etxt(0);
-  auto pt_len(0);  
-  
+  auto pt_len(0);
+
   vecInt vin(0);
   for (size_t i = 0; i < nbatch; i++) {
-    cout<<i<< '\r'<<flush;
-    //build a vector out of the batches 
-    for(size_t bat = 0; bat < ringsize; bat++){
-      if (i+(unsigned)offset[bat] >= txt.size()) {
+    cout << i << '\r' << flush;
+    //build a vector out of the batches
+    for (size_t bat = 0; bat < ringsize; bat++) {
+      if (i + (unsigned) offset[bat] >= txt.size()) {
         vin.push_back('\0'); //null terminate
       } else {
-        vin.push_back(txt[i+offset[bat]]);
+        vin.push_back(txt[i + offset[bat]]);
       }
     }
-    Plaintext pt= cc->MakePackedPlaintext(vin);
+    lbcrypto::Plaintext pt = cc->MakePackedPlaintext(vin);
     pt_len = pt->GetLength();
     vin.clear();
     CT ct = cc->Encrypt(keyPair.publicKey, pt);
     etxt.push_back(ct);
   }
-  cout<<"encrypted "<<etxt.size()<<" batches"<<endl;
+  cout << "encrypted " << etxt.size() << " batches" << endl;
 
-  cout<<"Step 3.2 - Encrypt pattern"<<endl;  
+  cout << "Step 3.2 - Encrypt pattern" << endl;
   //encrypt the pattern
   // we copy the pattern over the entire ring
   vecCT epat(0);
   unsigned int j(0);
-  for (auto ch: pat) {
-	cout<<j<< '\r'<<flush;
-	j++;
-	for(size_t bat = 0; bat < ringsize; bat++){
-	  vin.push_back(ch);
-	}
-	PT pt= cc->MakePackedPlaintext(vin);
-	vin.clear();
-	CT ct = cc->Encrypt(keyPair.publicKey, pt);
-	epat.push_back(ct);
-  }	
-
-  cout<<"Step 4 - Encrypted string search"<<endl;  
-
-  TIC(auto t2);
+  for (auto ch : pat) {
+    cout << j << '\r' << flush;
+    j++;
+    for (size_t bat = 0; bat < ringsize; bat++) {
+      vin.push_back(ch);
+    }
+    PT pt = cc->MakePackedPlaintext(vin);
+    vin.clear();
+    CT ct = cc->Encrypt(keyPair.publicKey, pt);
+    epat.push_back(ct);
+  }
+
+  cout << "Step 4 - Encrypted string search" << endl;
+
+  TIC(auto
+  t2);
 
   vecCT eresult = encrypted_search(cc, keyPair.publicKey, epat, etxt, p);
   auto encrypted_time_ms = TOC_MS(t2);
-  cout<< "Encrypted execution time "<<encrypted_time_ms<<" mSec."<<endl;  
+  cout << "Encrypted execution time " << encrypted_time_ms << " mSec." << endl;
 
   //decrypt the result and compute location of potential matches
   vecPT vecResult(0);
-  for (auto e_itr:eresult){
-	PT ptresult;  
-	cc->Decrypt(keyPair.secretKey, e_itr, &ptresult);
-	ptresult->SetLength(pt_len);
-	vecResult.push_back(ptresult);
+  for (auto e_itr : eresult) {
+    PT ptresult;
+    cc->Decrypt(keyPair.secretKey, e_itr, &ptresult);
+    ptresult->SetLength(pt_len);
+    vecResult.push_back(ptresult);
   }
 
   vecInt foundloc(0);
   for (size_t i = 0; i < vecResult.size(); i++) {
     auto unpackedVal = vecResult[i]->GetPackedValue();
-    for (size_t jj = 0; jj< ringsize; jj++) {
-      if (unpackedVal[jj] == 0) {
-      auto loc = i + offset[jj];
-      foundloc.push_back(loc);
+    for (size_t j = 0; j < ringsize; j++) {
+      if (unpackedVal[j] == 0) {
+        auto loc = i + offset[j];
+        foundloc.push_back(loc);
       }
     }
   }
 
   sort(foundloc.begin(), foundloc.end());
-  cout<<"total occurences "<<foundloc.size()<<endl;
+  cout << "total occurences " << foundloc.size() << endl;
 
   if (presult.size() != foundloc.size()) {
-    cout<<"encrypted and plaintext results do not match"<<endl; 
-    
+    cout << "encrypted and plaintext results do not match" << endl;
+
     size_t smaller = min(presult.size(), foundloc.size());
-    
+
     for (size_t i = 0; i < smaller; i++) {
       if (presult[i] != foundloc[i]) {
-      cout <<"mismatch at location "<< i <<endl;
+        cout << "mismatch at location " << i << endl;
       }
-    }      
-    if (presult.size()<foundloc.size()) {
-      for (size_t i = smaller; i< foundloc.size(); i++) {
-      cout <<"encrypted extra finds "<<i<< foundloc[i]<<endl;
+    }
+    if (presult.size() < foundloc.size()) {
+      for (size_t i = smaller; i < foundloc.size(); i++) {
+        cout << "encrypted extra finds " << i << foundloc[i] << endl;
       }
     } else {
-      for (size_t i = smaller; i< presult.size(); i++) {
-      cout <<"plaintext extra finds "<<i<<" "<< presult[i]<<endl;
+      for (size_t i = smaller; i < presult.size(); i++) {
+        cout << "plaintext extra finds " << i << " " << presult[i] << endl;
       }
     }
   } else {
-	  cout<<"encrypted and plaintext results match"<<endl;
+    cout << "encrypted and plaintext results match" << endl;
   }
   return 0;
 }