diff --git a/ft8/fft.cpp b/ft8/fft.cpp
index 623a2b4fc..220fad8c4 100644
--- a/ft8/fft.cpp
+++ b/ft8/fft.cpp
@@ -19,7 +19,7 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////
 
-#include <assert.h>
+// #include <assert.h>
 #include <QDebug>
 #include "fft.h"
 #include "util.h"
@@ -83,9 +83,9 @@ FFTEngine::Plan *FFTEngine::get_plan(int n, const char *why)
     p->uses_ = 1;
     p->why_ = why;
     p->r_ = (float *)fftwf_malloc(n * sizeof(float));
-    assert(p->r_);
+    // assert(p->r_);
     p->c_ = (fftwf_complex *)fftwf_malloc(((n / 2) + 1) * sizeof(fftwf_complex));
-    assert(p->c_);
+    // assert(p->c_);
 
     // FFTW_ESTIMATE
     // FFTW_MEASURE
@@ -94,25 +94,25 @@ FFTEngine::Plan *FFTEngine::get_plan(int n, const char *why)
     int type = M_FFTW_TYPE;
     p->type_ = type;
     p->fwd_ = fftwf_plan_dft_r2c_1d(n, p->r_, p->c_, type);
-    assert(p->fwd_);
+    // assert(p->fwd_);
     p->rev_ = fftwf_plan_dft_c2r_1d(n, p->c_, p->r_, type);
-    assert(p->rev_);
+    // assert(p->rev_);
 
     //
     // complex -> complex
     //
     p->cc1_ = (fftwf_complex *)fftwf_malloc(n * sizeof(fftwf_complex));
-    assert(p->cc1_);
+    // assert(p->cc1_);
     p->cc2_ = (fftwf_complex *)fftwf_malloc(n * sizeof(fftwf_complex));
-    assert(p->cc2_);
+    // assert(p->cc2_);
     p->cfwd_ = fftwf_plan_dft_1d(n, p->cc1_, p->cc2_, FFTW_FORWARD, type);
-    assert(p->cfwd_);
+    // assert(p->cfwd_);
     p->crev_ = fftwf_plan_dft_1d(n, p->cc2_, p->cc1_, FFTW_BACKWARD, type);
-    assert(p->crev_);
+    // assert(p->crev_);
 
     m_plansmu2.unlock();
 
-    assert(m_nplans + 1 < 1000);
+    // assert(m_nplans + 1 < 1000);
 
     m_plans[m_nplans] = p;
     m_nplans += 1;
@@ -144,15 +144,15 @@ std::vector<std::complex<float>> FFTEngine::one_fft(
     FFTEngine::Plan *p
 )
 {
-    assert(i0 >= 0);
-    assert(block > 1);
+    // assert(i0 >= 0);
+    // assert(block > 1);
 
     int nsamples = samples.size();
     int nbins = (block / 2) + 1;
 
     if (p)
     {
-        assert(p->n_ == block);
+        // assert(p->n_ == block);
         p->uses_ += 1;
     }
     else
@@ -165,7 +165,7 @@ std::vector<std::complex<float>> FFTEngine::one_fft(
     double t0 = now();
 #endif
 
-    assert((int)samples.size() - i0 >= block);
+    // assert((int)samples.size() - i0 >= block);
 
     int m_in_allocated = 0;
     float *m_in = (float *)samples.data() + i0;
@@ -174,7 +174,7 @@ std::vector<std::complex<float>> FFTEngine::one_fft(
     {
         // m_in must be on a 16-byte boundary for FFTW.
         m_in = (float *)fftwf_malloc(sizeof(float) * p->n_);
-        assert(m_in);
+        // assert(m_in);
         m_in_allocated = 1;
         for (int i = 0; i < block; i++)
         {
@@ -190,7 +190,7 @@ std::vector<std::complex<float>> FFTEngine::one_fft(
     }
 
     fftwf_complex *m_out = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) * ((p->n_ / 2) + 1));
-    assert(m_out);
+    // assert(m_out);
 
     fftwf_execute_dft_r2c(m_plan, m_in, m_out);
 
@@ -220,8 +220,8 @@ std::vector<std::complex<float>> FFTEngine::one_fft(
 //
 FFTEngine::ffts_t FFTEngine::ffts(const std::vector<float> &samples, int i0, int block, const char *why)
 {
-    assert(i0 >= 0);
-    assert(block > 1 && (block % 2) == 0);
+    // assert(i0 >= 0);
+    // assert(block > 1 && (block % 2) == 0);
 
     int nsamples = samples.size();
     int nbins = (block / 2) + 1;
@@ -242,7 +242,7 @@ FFTEngine::ffts_t FFTEngine::ffts(const std::vector<float> &samples, int i0, int
     // allocate our own b/c using p->m_in and p->m_out isn't thread-safe.
     float *m_in = (float *)fftwf_malloc(sizeof(float) * p->n_);
     fftwf_complex *m_out = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) * ((p->n_ / 2) + 1));
-    assert(m_in && m_out);
+    // assert(m_in && m_out);
 
     // float *m_in = p->r_;
     // fftw_complex *m_out = p->c_;
@@ -296,8 +296,8 @@ std::vector<std::complex<float>> FFTEngine::one_fft_c(
     const char *why
 )
 {
-    assert(i0 >= 0);
-    assert(block > 1);
+    // assert(i0 >= 0);
+    // assert(block > 1);
 
     int nsamples = samples.size();
 
@@ -310,7 +310,7 @@ std::vector<std::complex<float>> FFTEngine::one_fft_c(
 
     fftwf_complex *m_in = (fftwf_complex *)fftwf_malloc(block * sizeof(fftwf_complex));
     fftwf_complex *m_out = (fftwf_complex *)fftwf_malloc(block * sizeof(fftwf_complex));
-    assert(m_in && m_out);
+    // assert(m_in && m_out);
 
     for (int i = 0; i < block; i++)
     {
@@ -356,8 +356,8 @@ std::vector<std::complex<float>> FFTEngine::one_fft_cc(
     const char *why
 )
 {
-    assert(i0 >= 0);
-    assert(block > 1);
+    // assert(i0 >= 0);
+    // assert(block > 1);
 
     int nsamples = samples.size();
 
@@ -370,7 +370,7 @@ std::vector<std::complex<float>> FFTEngine::one_fft_cc(
 
     fftwf_complex *m_in = (fftwf_complex *)fftwf_malloc(block * sizeof(fftwf_complex));
     fftwf_complex *m_out = (fftwf_complex *)fftwf_malloc(block * sizeof(fftwf_complex));
-    assert(m_in && m_out);
+    // assert(m_in && m_out);
 
     for (int i = 0; i < block; i++)
     {
@@ -426,7 +426,7 @@ std::vector<std::complex<float>> FFTEngine::one_ifft_cc(
 
     fftwf_complex *m_in = (fftwf_complex *)fftwf_malloc(block * sizeof(fftwf_complex));
     fftwf_complex *m_out = (fftwf_complex *)fftwf_malloc(block * sizeof(fftwf_complex));
-    assert(m_in && m_out);
+    // assert(m_in && m_out);
 
     for (int bi = 0; bi < block; bi++)
     {
@@ -512,7 +512,7 @@ std::vector<std::complex<float>> FFTEngine::analytic(const std::vector<float> &x
     ulong n = x.size();
 
     std::vector<std::complex<float>> y = one_fft_c(x, 0, n, why);
-    assert(y.size() == n);
+    // assert(y.size() == n);
 
     // leave y[0] alone.
     // float the first (positive) half of the spectrum.
@@ -553,7 +553,7 @@ std::vector<float> FFTEngine::hilbert_shift(const std::vector<float> &x, float h
 {
     // y = scipy.signal.hilbert(x)
     std::vector<std::complex<float>> y = analytic(x, "hilbert_shift");
-    assert(y.size() == x.size());
+    // assert(y.size() == x.size());
 
     float dt = 1.0 / rate;
     int n = x.size();
diff --git a/ft8/ft8.cpp b/ft8/ft8.cpp
index d0f33327d..13f8bf958 100644
--- a/ft8/ft8.cpp
+++ b/ft8/ft8.cpp
@@ -29,7 +29,7 @@
 //
 
 #include <stdio.h>
-#include <assert.h>
+// #include <assert.h>
 #include <math.h>
 #include <complex>
 #include <fftw3.h>
@@ -373,8 +373,8 @@ float FT8::one_coarse_strength(const FFTEngine::ffts_t &bins, int bi0, int si0)
 {
     int costas[] = {3, 1, 4, 0, 6, 5, 2};
 
-    assert(si0 >= 0 && si0 + 72 + 8 <= (int)bins.size());
-    assert(bi0 >= 0 && bi0 + 8 <= (int)bins[0].size());
+    // assert(si0 >= 0 && si0 + 72 + 8 <= (int)bins.size());
+    // assert(bi0 >= 0 && bi0 + 8 <= (int)bins[0].size());
 
     float sig = 0.0;
     float noise = 0.0;
@@ -486,8 +486,7 @@ float FT8::one_coarse_strength(const FFTEngine::ffts_t &bins, int bi0, int si0)
 int FT8::blocksize(int rate)
 {
     // FT8 symbol length is 1920 at 12000 samples/second.
-    int xblock = 1920 / (12000.0 / rate);
-    assert(xblock == (int)xblock);
+    int xblock = (1920*rate) / 12000;
     int block = xblock;
     return block;
 }
@@ -561,8 +560,8 @@ std::vector<float> FT8::reduce_rate(
     float &delta_hz
 )
 {
-    assert(brate < arate);
-    assert(hz1 - hz0 <= brate / 2);
+    // assert(brate < arate);
+    // assert(hz1 - hz0 <= brate / 2);
 
     // the pass band is hz0..hz1
     // stop bands are 0..hz00 and hz11..nyquist.
@@ -621,7 +620,7 @@ std::vector<float> FT8::reduce_rate(
     int nmid = (brate / 4.0) / bin_hz;
 
     int delta = omid - nmid; // amount to move down
-    assert(delta < nbins1);
+    // assert(delta < nbins1);
     int blen = round(alen * (brate / (float)arate));
     std::vector<std::complex<float>> bbins(blen / 2 + 1);
     for (int i = 0; i < (int)bbins.size(); i++)
@@ -677,7 +676,7 @@ void FT8::go(int npasses)
         samples_.resize(nice);
     }
 
-    assert(min_hz_ >= 0 && max_hz_ + 50 <= rate_ / 2);
+    // assert(min_hz_ >= 0 && max_hz_ + 50 <= rate_ / 2);
 
     // can we reduce the sample rate?
     int nrate = -1;
@@ -742,8 +741,8 @@ void FT8::go(int npasses)
             }
         }
 
-        assert(max_hz_ + 50 < nrate / 2);
-        assert(min_hz_ >= 0);
+        // assert(max_hz_ + 50 < nrate / 2);
+        // assert(min_hz_ >= 0);
 
         float ratio = nrate / (float)rate_;
         rate_ = nrate;
@@ -999,7 +998,7 @@ float FT8::one_strength_known(
 )
 {
     int block = blocksize(rate);
-    assert(syms.size() == 79);
+    // assert(syms.size() == 79);
 
     int bin0 = round(hz / 6.25);
 
@@ -1118,7 +1117,7 @@ int FT8::search_time_fine(
     }
 
     str = best_sum;
-    assert(best_off >= 0);
+    // assert(best_off >= 0);
     return off0 + best_off;
 }
 
@@ -1181,7 +1180,7 @@ std::vector<Strength> FT8::search_both(
     int off_win
 )
 {
-    assert(hz0 >= 25 - 6.25 / 2 && hz0 <= 25 + 6.25 / 2);
+    // assert(hz0 >= 25 - 6.25 / 2 && hz0 <= 25 + 6.25 / 2);
 
     std::vector<Strength> strengths;
 
@@ -1218,7 +1217,7 @@ void FT8::search_both_known(
     float &off_out
 )
 {
-    assert(hz0 >= 0 && hz0 + 50 < rate / 2);
+    // assert(hz0 >= 0 && hz0 + 50 < rate / 2);
 
     int off0 = round(off_secs0 * (float)rate);
 
@@ -1976,7 +1975,7 @@ void FT8::soft_decode(const FFTEngine::ffts_t &c79, float ll174[])
             ll174[lli++] = ll;
         }
     }
-    assert(lli == 174);
+    // assert(lli == 174);
 }
 
 //
@@ -2153,7 +2152,7 @@ void FT8::c_soft_decode(const FFTEngine::ffts_t &c79x, float ll174[])
             ll174[lli++] = ll;
         }
     }
-    assert(lli == 174);
+    // assert(lli == 174);
 }
 
 //
@@ -2168,8 +2167,8 @@ void FT8::c_soft_decode(const FFTEngine::ffts_t &c79x, float ll174[])
 //
 std::vector<float> FT8::extract_bits(const std::vector<int> &syms, const std::vector<float> str)
 {
-    assert(syms.size() == 79);
-    assert(str.size() == 79);
+    // assert(syms.size() == 79);
+    // assert(str.size() == 79);
 
     std::vector<float> bits;
     for (int si = 0; si < 79; si++)
@@ -2323,7 +2322,7 @@ void FT8::soft_decode_pairs(
             ll174[lli++] = ll;
         }
     }
-    assert(lli == 174);
+    // assert(lli == 174);
 }
 
 void FT8::soft_decode_triples(
@@ -2485,7 +2484,7 @@ void FT8::soft_decode_triples(
             ll174[lli++] = ll;
         }
     }
-    assert(lli == 174);
+    // assert(lli == 174);
 }
 
 //
@@ -2552,11 +2551,9 @@ std::vector<std::complex<float>> FT8::fbandpass(
     float high_outer  // end of transition
 )
 {
-    // assert(low_outer >= 0);
-    assert(low_outer <= low_inner);
-    assert(low_inner <= high_inner);
-    assert(high_inner <= high_outer);
-    // assert(high_outer <= bin_hz * bins0.size());
+    // assert(low_outer <= low_inner);
+    // assert(low_inner <= high_inner);
+    // assert(high_inner <= high_outer);
 
     int nbins = bins0.size();
     std::vector<std::complex<float>> bins1(nbins);
@@ -3449,8 +3446,8 @@ std::vector<int> FT8::recode(int a174[])
             out79.push_back(sym);
         }
     }
-    assert(out79.size() == 79);
-    assert(i174 == 174);
+    // assert(out79.size() == 79);
+    // assert(i174 == 174);
     return out79;
 }
 
diff --git a/ft8/libldpc.cpp b/ft8/libldpc.cpp
index e0f1c1611..4c8c6726f 100644
--- a/ft8/libldpc.cpp
+++ b/ft8/libldpc.cpp
@@ -37,7 +37,6 @@
 #include <stdio.h>
 #include <math.h>
 #include <stdlib.h>
-#include <assert.h>
 #include "arrays.h"
 
 // float, long float, __float128
@@ -414,8 +413,9 @@ void gauss_jordan(int rows, int cols, int m[174][2 * 91], int which[91], int *ok
 {
     *ok = 0;
 
-    assert(rows == 91);
-    assert(cols == 174);
+    if ((rows != 91) || (cols != 174)) {
+        return;
+    }
 
     for (int row = 0; row < rows; row++)
     {
diff --git a/ft8/unpack.cpp b/ft8/unpack.cpp
index fbc67f252..d01ded9c8 100644
--- a/ft8/unpack.cpp
+++ b/ft8/unpack.cpp
@@ -19,7 +19,6 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////
 #include <string>
-#include <assert.h>
 
 #include "unpack.h"
 #include "unpack0.h"
@@ -42,9 +41,12 @@ int Packing::ihashcall(std::string rawcall, int m)
     {
         int c = call[i];
         const char *p = strchr(chars, c);
-        assert(p);
-        int j = p - chars;
-        x = 38 * x + j;
+
+        if (p)
+        {
+            int j = p - chars;
+            x = 38 * x + j;
+        }
     }
 
     x = x * 47055833459LL;
@@ -319,7 +321,10 @@ std::string Packing::unpack_1(int a77[], std::string& call1str, std::string& cal
     i += 15;
     int i3 = un64(a77, i, 3);
     i += 3;
-    assert((i3 == 1 || i3 == 2) && i == 77);
+
+    if (!((i3 == 1 || i3 == 2) && i == 77)) {
+        return std::string("");
+    }
 
     call1str = trim(unpackcall(call1));
     call2str = trim(unpackcall(call2));
diff --git a/ft8/unpack0.cpp b/ft8/unpack0.cpp
index f781f3995..f13a1a459 100644
--- a/ft8/unpack0.cpp
+++ b/ft8/unpack0.cpp
@@ -32,7 +32,7 @@ boost::multiprecision::int128_t un128(int a77[], int start, int len)
 {
     boost::multiprecision::int128_t x = 0;
 
-    assert(len < (int)sizeof(x) * 8 && start >= 0 && start + len <= 77);
+    // assert(len < (int)sizeof(x) * 8 && start >= 0 && start + len <= 77);
     for (int i = 0; i < len; i++)
     {
         x <<= 1;
@@ -50,7 +50,7 @@ uint64_t un64(int a77[], int start, int len)
 {
     uint64_t x = 0;
 
-    assert(len < (int)sizeof(x) * 8 && start >= 0 && start + len <= 63);
+    // assert(len < (int)sizeof(x) * 8 && start >= 0 && start + len <= 63);
     for (int i = 0; i < len; i++)
     {
         x <<= 1;
diff --git a/ft8/util.cpp b/ft8/util.cpp
index 76901ed6c..547d31df9 100644
--- a/ft8/util.cpp
+++ b/ft8/util.cpp
@@ -18,7 +18,6 @@
 // You should have received a copy of the GNU General Public License             //
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////
-#include <assert.h>
 #include <math.h>
 #include <complex>
 #include <string>
@@ -175,7 +174,11 @@ std::vector<std::complex<float>> gfsk_c(
     const std::vector<float> &gwin
 )
 {
-    assert((gwin.size() % 2) == 0);
+    if (!((gwin.size() % 2) == 0))
+    {
+        std::vector<std::complex<float>> v(symsamples * symbols.size());
+        return v;
+    }
 
     // compute frequency for each symbol.
     // generate a spike in the middle of each symbol time;
@@ -251,7 +254,11 @@ std::vector<float> gfsk_r(
     const std::vector<float> &gwin
 )
 {
-    assert((gwin.size() % 2) == 0);
+    if (!((gwin.size() % 2) == 0))
+    {
+        std::vector<float> v(symsamples * symbols.size());
+        return v;
+    }
 
     // compute frequency for each symbol.
     // generate a spike in the middle of each symbol time;