diff -r 8621727dd9f7 Modules/_ctypes/_ctypes.c
--- a/Modules/_ctypes/_ctypes.c	Thu Nov 05 17:51:15 2015 +0200
+++ b/Modules/_ctypes/_ctypes.c	Thu Nov 05 18:42:06 2015 +0200
@@ -2386,7 +2386,7 @@ unique_key(CDataObject *target, Py_ssize
     char *cp = string;
     size_t bytes_left;
 
-    assert(sizeof(string) - 1 > sizeof(Py_ssize_t) * 2);
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(string) - 1 > sizeof(Py_ssize_t) * 2);
     cp += sprintf(cp, "%x", Py_SAFE_DOWNCAST(index, Py_ssize_t, int));
     while (target->b_base) {
         bytes_left = sizeof(string) - (cp - string) - 1;
diff -r 8621727dd9f7 Modules/_datetimemodule.c
--- a/Modules/_datetimemodule.c	Thu Nov 05 17:51:15 2015 +0200
+++ b/Modules/_datetimemodule.c	Thu Nov 05 18:42:06 2015 +0200
@@ -5329,19 +5329,19 @@ PyInit__datetime(void)
     /* A 4-year cycle has an extra leap day over what we'd get from
      * pasting together 4 single years.
      */
-    assert(DI4Y == 4 * 365 + 1);
+    (void)Py_BUILD_ASSERT_EXPR(DI4Y == 4 * 365 + 1);
     assert(DI4Y == days_before_year(4+1));
 
     /* Similarly, a 400-year cycle has an extra leap day over what we'd
      * get from pasting together 4 100-year cycles.
      */
-    assert(DI400Y == 4 * DI100Y + 1);
+    (void)Py_BUILD_ASSERT_EXPR(DI400Y == 4 * DI100Y + 1);
     assert(DI400Y == days_before_year(400+1));
 
     /* OTOH, a 100-year cycle has one fewer leap day than we'd get from
      * pasting together 25 4-year cycles.
      */
-    assert(DI100Y == 25 * DI4Y - 1);
+    (void)Py_BUILD_ASSERT_EXPR(DI100Y == 25 * DI4Y - 1);
     assert(DI100Y == days_before_year(100+1));
 
     one = PyLong_FromLong(1);
diff -r 8621727dd9f7 Modules/_decimal/_decimal.c
--- a/Modules/_decimal/_decimal.c	Thu Nov 05 17:51:15 2015 +0200
+++ b/Modules/_decimal/_decimal.c	Thu Nov 05 18:42:06 2015 +0200
@@ -610,7 +610,7 @@ signaldict_repr(PyObject *self)
     const char *b[SIGNAL_MAP_LEN]; /* bool */
     int i;
 
-    assert(SIGNAL_MAP_LEN == 9);
+    (void)Py_BUILD_ASSERT_EXPR(SIGNAL_MAP_LEN == 9);
 
     for (cm=signal_map, i=0; cm->name != NULL; cm++, i++) {
         n[i] = cm->fqname;
diff -r 8621727dd9f7 Modules/_pickle.c
--- a/Modules/_pickle.c	Thu Nov 05 17:51:15 2015 +0200
+++ b/Modules/_pickle.c	Thu Nov 05 18:42:06 2015 +0200
@@ -874,7 +874,7 @@ static void
 {
     size_t i;
 
-    assert(sizeof(size_t) <= 8);
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(size_t) <= 8);
 
     for (i = 0; i < sizeof(size_t); i++) {
         out[i] = (unsigned char)((value >> (8 * i)) & 0xff);
diff -r 8621727dd9f7 Modules/pyexpat.c
--- a/Modules/pyexpat.c	Thu Nov 05 17:51:15 2015 +0200
+++ b/Modules/pyexpat.c	Thu Nov 05 18:42:06 2015 +0200
@@ -747,7 +747,8 @@ pyexpat_xmlparser_Parse_impl(xmlparseobj
         s += MAX_CHUNK_SIZE;
         slen -= MAX_CHUNK_SIZE;
     }
-    assert(MAX_CHUNK_SIZE < INT_MAX && slen < INT_MAX);
+    (void)Py_BUILD_ASSERT_EXPR(MAX_CHUNK_SIZE < INT_MAX);
+    assert(slen < INT_MAX);
     rc = XML_Parse(self->itself, s, (int)slen, isfinal);
 
 done:
diff -r 8621727dd9f7 Python/pytime.c
--- a/Python/pytime.c	Thu Nov 05 17:51:15 2015 +0200
+++ b/Python/pytime.c	Thu Nov 05 18:42:06 2015 +0200
@@ -43,7 +43,7 @@ time_t
     val = PyLong_AsLongLong(obj);
 #else
     long val;
-    assert(sizeof(time_t) <= sizeof(long));
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(time_t) <= sizeof(long));
     val = PyLong_AsLong(obj);
 #endif
     if (val == -1 && PyErr_Occurred()) {
@@ -60,7 +60,7 @@ PyObject *
 #if defined(HAVE_LONG_LONG) && SIZEOF_TIME_T == SIZEOF_LONG_LONG
     return PyLong_FromLongLong((PY_LONG_LONG)t);
 #else
-    assert(sizeof(time_t) <= sizeof(long));
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(time_t) <= sizeof(long));
     return PyLong_FromLong((long)t);
 #endif
 }
@@ -219,7 +219,7 @@ static void
 _PyTime_FromNanoseconds(PY_LONG_LONG ns)
 {
     _PyTime_t t;
-    assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
     t = Py_SAFE_DOWNCAST(ns, PY_LONG_LONG, _PyTime_t);
     return t;
 }
@@ -231,7 +231,7 @@ static int
     _PyTime_t t;
     int res = 0;
 
-    assert(sizeof(ts->tv_sec) <= sizeof(_PyTime_t));
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(ts->tv_sec) <= sizeof(_PyTime_t));
     t = (_PyTime_t)ts->tv_sec;
 
     if (_PyTime_check_mul_overflow(t, SEC_TO_NS)) {
@@ -253,7 +253,7 @@ static int
     _PyTime_t t;
     int res = 0;
 
-    assert(sizeof(tv->tv_sec) <= sizeof(_PyTime_t));
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(tv->tv_sec) <= sizeof(_PyTime_t));
     t = (_PyTime_t)tv->tv_sec;
 
     if (_PyTime_check_mul_overflow(t, SEC_TO_NS)) {
@@ -304,12 +304,12 @@ static int
     else {
 #ifdef HAVE_LONG_LONG
         PY_LONG_LONG sec;
-        assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
+        (void)Py_BUILD_ASSERT_EXPR(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
 
         sec = PyLong_AsLongLong(obj);
 #else
         long sec;
-        assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
+        (void)Py_BUILD_ASSERT_EXPR(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
 
         sec = PyLong_AsLong(obj);
 #endif
@@ -364,10 +364,10 @@ PyObject *
 _PyTime_AsNanosecondsObject(_PyTime_t t)
 {
 #ifdef HAVE_LONG_LONG
-    assert(sizeof(PY_LONG_LONG) >= sizeof(_PyTime_t));
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(PY_LONG_LONG) >= sizeof(_PyTime_t));
     return PyLong_FromLongLong((PY_LONG_LONG)t);
 #else
-    assert(sizeof(long) >= sizeof(_PyTime_t));
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(long) >= sizeof(_PyTime_t));
     return PyLong_FromLong((long)t);
 #endif
 }
@@ -650,7 +650,7 @@ pymonotonic(_PyTime_t *tp, _Py_clock_inf
     assert(info == NULL || raise);
 
     ticks = GetTickCount64();
-    assert(sizeof(ticks) <= sizeof(_PyTime_t));
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(ticks) <= sizeof(_PyTime_t));
     t = (_PyTime_t)ticks;
 
     if (_PyTime_check_mul_overflow(t, MS_TO_NS)) {
@@ -775,7 +775,7 @@ int
         return -1;
 
     /* check that _PyTime_FromSeconds() cannot overflow */
-    assert(INT_MAX <= _PyTime_MAX / SEC_TO_NS);
-    assert(INT_MIN >= _PyTime_MIN / SEC_TO_NS);
+    (void)Py_BUILD_ASSERT_EXPR(INT_MAX <= _PyTime_MAX / SEC_TO_NS);
+    (void)Py_BUILD_ASSERT_EXPR(INT_MIN >= _PyTime_MIN / SEC_TO_NS);
     return 0;
 }
diff -r 8621727dd9f7 Python/random.c
--- a/Python/random.c	Thu Nov 05 17:51:15 2015 +0200
+++ b/Python/random.c	Thu Nov 05 18:42:06 2015 +0200
@@ -379,7 +379,7 @@ void
     char *env;
     unsigned char *secret = (unsigned char *)&_Py_HashSecret.uc;
     Py_ssize_t secret_size = sizeof(_Py_HashSecret_t);
-    assert(secret_size == sizeof(_Py_HashSecret.uc));
+    (void)Py_BUILD_ASSERT_EXPR(sizeof(_Py_HashSecret_t) == sizeof(_Py_HashSecret.uc));
 
     if (_Py_HashSecret_Initialized)
         return;