diff --git a/Modules/zlibmodule.c b/Modules/zlibmodule.c
index fd30649..def6176 100644
--- a/Modules/zlibmodule.c
+++ b/Modules/zlibmodule.c
@@ -37,18 +37,16 @@
     PyTypeObject *Comptype;
     PyTypeObject *Decomptype;
     PyObject *ZlibError;
-} _zlibstate;
+} zlibstate;
 
-static inline _zlibstate*
+static inline zlibstate*
 get_zlib_state(PyObject *module)
 {
     void *state = PyModule_GetState(module);
     assert(state != NULL);
-    return (_zlibstate *)state;
+    return (zlibstate *)state;
 }
 
-#define _zlibstate_global ((_zlibstate *)PyModule_GetState(PyState_FindModule(&zlibmodule)))
-
 typedef struct
 {
     PyObject_HEAD
@@ -62,7 +60,7 @@
 } compobject;
 
 static void
-zlib_error(z_stream zst, int err, const char *msg)
+zlib_error(zlibstate *state, z_stream zst, int err, const char *msg)
 {
     const char *zmsg = Z_NULL;
     /* In case of a version mismatch, zst.msg won't be initialized.
@@ -85,9 +83,9 @@
         }
     }
     if (zmsg == Z_NULL)
-        PyErr_Format(_zlibstate_global->ZlibError, "Error %d %s", err, msg);
+        PyErr_Format(state->ZlibError, "Error %d %s", err, msg);
     else
-        PyErr_Format(_zlibstate_global->ZlibError, "Error %d %s: %.200s", err, msg, zmsg);
+        PyErr_Format(state->ZlibError, "Error %d %s: %.200s", err, msg, zmsg);
 }
 
 /*[clinic input]
@@ -216,19 +214,20 @@
 /*[clinic end generated code: output=d80906d73f6294c8 input=638d54b6315dbed3]*/
 {
     PyObject *RetVal = NULL;
-    Byte *ibuf;
-    Py_ssize_t ibuflen, obuflen = DEF_BUF_SIZE;
-    int err, flush;
+    Py_ssize_t obuflen = DEF_BUF_SIZE;
+    int flush;
     z_stream zst;
 
-    ibuf = data->buf;
-    ibuflen = data->len;
+    zlibstate *state = get_zlib_state(module);
+
+    Byte *ibuf = data->buf;
+    Py_ssize_t ibuflen = data->len;
 
     zst.opaque = NULL;
     zst.zalloc = PyZlib_Malloc;
     zst.zfree = PyZlib_Free;
     zst.next_in = ibuf;
-    err = deflateInit(&zst, level);
+    int err = deflateInit(&zst, level);
 
     switch (err) {
     case Z_OK:
@@ -238,11 +237,11 @@
                         "Out of memory while compressing data");
         goto error;
     case Z_STREAM_ERROR:
-        PyErr_SetString(_zlibstate_global->ZlibError, "Bad compression level");
+        PyErr_SetString(state->ZlibError, "Bad compression level");
         goto error;
     default:
         deflateEnd(&zst);
-        zlib_error(zst, err, "while compressing data");
+        zlib_error(state, zst, err, "while compressing data");
         goto error;
     }
 
@@ -263,7 +262,7 @@
 
             if (err == Z_STREAM_ERROR) {
                 deflateEnd(&zst);
-                zlib_error(zst, err, "while compressing data");
+                zlib_error(state, zst, err, "while compressing data");
                 goto error;
             }
 
@@ -281,7 +280,7 @@
         return RetVal;
     }
     else
-        zlib_error(zst, err, "while finishing compression");
+        zlib_error(state, zst, err, "while finishing compression");
  error:
     Py_XDECREF(RetVal);
     return NULL;
@@ -312,6 +311,8 @@
     int err, flush;
     z_stream zst;
 
+    zlibstate *state = get_zlib_state(module);
+
     if (bufsize < 0) {
         PyErr_SetString(PyExc_ValueError, "bufsize must be non-negative");
         return NULL;
@@ -338,7 +339,7 @@
         goto error;
     default:
         inflateEnd(&zst);
-        zlib_error(zst, err, "while preparing to decompress data");
+        zlib_error(state, zst, err, "while preparing to decompress data");
         goto error;
     }
 
@@ -369,7 +370,7 @@
                 goto error;
             default:
                 inflateEnd(&zst);
-                zlib_error(zst, err, "while decompressing data");
+                zlib_error(state, zst, err, "while decompressing data");
                 goto error;
             }
 
@@ -380,13 +381,13 @@
 
     if (err != Z_STREAM_END) {
         inflateEnd(&zst);
-        zlib_error(zst, err, "while decompressing data");
+        zlib_error(state, zst, err, "while decompressing data");
         goto error;
     }
 
     err = inflateEnd(&zst);
     if (err != Z_OK) {
-        zlib_error(zst, err, "while finishing decompression");
+        zlib_error(state, zst, err, "while finishing decompression");
         goto error;
     }
 
@@ -434,16 +435,14 @@
                       int memLevel, int strategy, Py_buffer *zdict)
 /*[clinic end generated code: output=8b5bed9c8fc3814d input=2fa3d026f90ab8d5]*/
 {
-    compobject *self = NULL;
-    int err;
-
+    zlibstate *state = get_zlib_state(module);
     if (zdict->buf != NULL && (size_t)zdict->len > UINT_MAX) {
         PyErr_SetString(PyExc_OverflowError,
                         "zdict length does not fit in an unsigned int");
-        goto error;
+        return NULL;
     }
 
-    self = newcompobject(_zlibstate_global->Comptype);
+    compobject *self = newcompobject(state->Comptype);
     if (self == NULL)
         goto error;
     self->zst.opaque = NULL;
@@ -451,7 +450,7 @@
     self->zst.zfree = PyZlib_Free;
     self->zst.next_in = NULL;
     self->zst.avail_in = 0;
-    err = deflateInit2(&self->zst, level, method, wbits, memLevel, strategy);
+    int err = deflateInit2(&self->zst, level, method, wbits, memLevel, strategy);
     switch (err) {
     case Z_OK:
         self->is_initialised = 1;
@@ -479,7 +478,7 @@
         PyErr_SetString(PyExc_ValueError, "Invalid initialization option");
         goto error;
     default:
-        zlib_error(self->zst, err, "while creating compression object");
+        zlib_error(state, self->zst, err, "while creating compression object");
         goto error;
     }
 
@@ -490,11 +489,9 @@
 }
 
 static int
-set_inflate_zdict(compobject *self)
+set_inflate_zdict(zlibstate *state, compobject *self)
 {
     Py_buffer zdict_buf;
-    int err;
-
     if (PyObject_GetBuffer(self->zdict, &zdict_buf, PyBUF_SIMPLE) == -1) {
         return -1;
     }
@@ -504,11 +501,12 @@
         PyBuffer_Release(&zdict_buf);
         return -1;
     }
+    int err;
     err = inflateSetDictionary(&self->zst,
                                zdict_buf.buf, (unsigned int)zdict_buf.len);
     PyBuffer_Release(&zdict_buf);
     if (err != Z_OK) {
-        zlib_error(self->zst, err, "while setting zdict");
+        zlib_error(state, self->zst, err, "while setting zdict");
         return -1;
     }
     return 0;
@@ -530,8 +528,7 @@
 zlib_decompressobj_impl(PyObject *module, int wbits, PyObject *zdict)
 /*[clinic end generated code: output=3069b99994f36906 input=d3832b8511fc977b]*/
 {
-    int err;
-    compobject *self;
+    zlibstate *state = get_zlib_state(module);
 
     if (zdict != NULL && !PyObject_CheckBuffer(zdict)) {
         PyErr_SetString(PyExc_TypeError,
@@ -539,7 +536,7 @@
         return NULL;
     }
 
-    self = newcompobject(_zlibstate_global->Decomptype);
+    compobject *self = newcompobject(state->Decomptype);
     if (self == NULL)
         return NULL;
     self->zst.opaque = NULL;
@@ -551,18 +548,18 @@
         Py_INCREF(zdict);
         self->zdict = zdict;
     }
-    err = inflateInit2(&self->zst, wbits);
+    int err = inflateInit2(&self->zst, wbits);
     switch (err) {
     case Z_OK:
         self->is_initialised = 1;
         if (self->zdict != NULL && wbits < 0) {
 #ifdef AT_LEAST_ZLIB_1_2_2_1
-            if (set_inflate_zdict(self) < 0) {
+            if (set_inflate_zdict(state, self) < 0) {
                 Py_DECREF(self);
                 return NULL;
             }
 #else
-            PyErr_Format(_zlibstate_global->ZlibError,
+            PyErr_Format(state->ZlibError,
                          "zlib version %s does not allow raw inflate with dictionary",
                          ZLIB_VERSION);
             Py_DECREF(self);
@@ -580,7 +577,7 @@
                         "Can't allocate memory for decompression object");
         return NULL;
     default:
-        zlib_error(self->zst, err, "while creating decompression object");
+        zlib_error(state, self->zst, err, "while creating decompression object");
         Py_DECREF(self);
         return NULL;
     }
@@ -617,6 +614,7 @@
 /*[clinic input]
 zlib.Compress.compress
 
+    cls: defining_class
     data: Py_buffer
         Binary data to be compressed.
     /
@@ -629,15 +627,18 @@
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Compress_compress_impl(compobject *self, Py_buffer *data)
-/*[clinic end generated code: output=5d5cd791cbc6a7f4 input=0d95908d6e64fab8]*/
+zlib_Compress_compress_impl(compobject *self, PyTypeObject *cls,
+                            Py_buffer *data)
+/*[clinic end generated code: output=6731b3f0ff357ca6 input=04d00f65ab01d260]*/
 {
     PyObject *RetVal = NULL;
-    Py_ssize_t ibuflen, obuflen = DEF_BUF_SIZE;
+    Py_ssize_t obuflen = DEF_BUF_SIZE;
     int err;
 
+    zlibstate *state = PyType_GetModuleState(cls);
+
     self->zst.next_in = data->buf;
-    ibuflen = data->len;
+    Py_ssize_t ibuflen = data->len;
 
     ENTER_ZLIB(self);
 
@@ -654,7 +655,7 @@
             Py_END_ALLOW_THREADS
 
             if (err == Z_STREAM_ERROR) {
-                zlib_error(self->zst, err, "while compressing data");
+                zlib_error(state, self->zst, err, "while compressing data");
                 goto error;
             }
 
@@ -722,6 +723,7 @@
 /*[clinic input]
 zlib.Decompress.decompress
 
+    cls: defining_class
     data: Py_buffer
         The binary data to decompress.
     /
@@ -738,14 +740,19 @@
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Decompress_decompress_impl(compobject *self, Py_buffer *data,
-                                Py_ssize_t max_length)
-/*[clinic end generated code: output=6e5173c74e710352 input=0a95d05a3bceaeaa]*/
+zlib_Decompress_decompress_impl(compobject *self, PyTypeObject *cls,
+                                Py_buffer *data, Py_ssize_t max_length)
+/*[clinic end generated code: output=b024a93c2c922d57 input=bfb37b3864cfb606]*/
 {
     int err = Z_OK;
     Py_ssize_t ibuflen, obuflen = DEF_BUF_SIZE, hard_limit;
     PyObject *RetVal = NULL;
 
+    PyObject *module = PyType_GetModule(cls);
+    if (module == NULL)
+        return NULL;
+
+    zlibstate *state = get_zlib_state(module);
     if (max_length < 0) {
         PyErr_SetString(PyExc_ValueError, "max_length must be non-negative");
         return NULL;
@@ -790,8 +797,9 @@
                 break;
             default:
                 if (err == Z_NEED_DICT && self->zdict != NULL) {
-                    if (set_inflate_zdict(self) < 0)
+                    if (set_inflate_zdict(state, self) < 0) {
                         goto abort;
+                    }
                     else
                         break;
                 }
@@ -815,7 +823,7 @@
            but there wasn't more output when we tried again, so it is
            not an error condition.
         */
-        zlib_error(self->zst, err, "while decompressing data");
+        zlib_error(state, self->zst, err, "while decompressing data");
         goto abort;
     }
 
@@ -833,6 +841,7 @@
 /*[clinic input]
 zlib.Compress.flush
 
+    cls: defining_class
     mode: int(c_default="Z_FINISH") = zlib.Z_FINISH
         One of the constants Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH.
         If mode == Z_FINISH, the compressor object can no longer be
@@ -844,13 +853,14 @@
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Compress_flush_impl(compobject *self, int mode)
-/*[clinic end generated code: output=a203f4cefc9de727 input=73ed066794bd15bc]*/
+zlib_Compress_flush_impl(compobject *self, PyTypeObject *cls, int mode)
+/*[clinic end generated code: output=c7efd13efd62add2 input=286146e29442eb6c]*/
 {
     int err;
     Py_ssize_t length = DEF_BUF_SIZE;
     PyObject *RetVal = NULL;
 
+    zlibstate *state = PyType_GetModuleState(cls);
     /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in
        doing any work at all; just return an empty string. */
     if (mode == Z_NO_FLUSH) {
@@ -873,7 +883,7 @@
         Py_END_ALLOW_THREADS
 
         if (err == Z_STREAM_ERROR) {
-            zlib_error(self->zst, err, "while flushing");
+            zlib_error(state, self->zst, err, "while flushing");
             Py_CLEAR(RetVal);
             goto error;
         }
@@ -886,7 +896,7 @@
     if (err == Z_STREAM_END && mode == Z_FINISH) {
         err = deflateEnd(&self->zst);
         if (err != Z_OK) {
-            zlib_error(self->zst, err, "while finishing compression");
+            zlib_error(state, self->zst, err, "while finishing compression");
             Py_CLEAR(RetVal);
             goto error;
         }
@@ -898,7 +908,7 @@
            not an error condition.
         */
     } else if (err != Z_OK && err != Z_BUF_ERROR) {
-        zlib_error(self->zst, err, "while flushing");
+        zlib_error(state, self->zst, err, "while flushing");
         Py_CLEAR(RetVal);
         goto error;
     }
@@ -917,24 +927,25 @@
 /*[clinic input]
 zlib.Compress.copy
 
+    cls: defining_class
+
 Return a copy of the compression object.
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Compress_copy_impl(compobject *self)
-/*[clinic end generated code: output=5144aa153c21e805 input=c656351f94b82718]*/
+zlib_Compress_copy_impl(compobject *self, PyTypeObject *cls)
+/*[clinic end generated code: output=c4d2cfb4b0d7350b input=235497e482d40986]*/
 {
-    compobject *retval = NULL;
-    int err;
+    zlibstate *state = PyType_GetModuleState(cls);
 
-    retval = newcompobject(_zlibstate_global->Comptype);
+    compobject *retval = newcompobject(state->Comptype);
     if (!retval) return NULL;
 
     /* Copy the zstream state
      * We use ENTER_ZLIB / LEAVE_ZLIB to make this thread-safe
      */
     ENTER_ZLIB(self);
-    err = deflateCopy(&retval->zst, &self->zst);
+    int err = deflateCopy(&retval->zst, &self->zst);
     switch (err) {
     case Z_OK:
         break;
@@ -946,7 +957,7 @@
                         "Can't allocate memory for compression object");
         goto error;
     default:
-        zlib_error(self->zst, err, "while copying compression object");
+        zlib_error(state, self->zst, err, "while copying compression object");
         goto error;
     }
     Py_INCREF(self->unused_data);
@@ -971,51 +982,57 @@
 
 /*[clinic input]
 zlib.Compress.__copy__
+
+    cls: defining_class
+
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Compress___copy___impl(compobject *self)
-/*[clinic end generated code: output=1875e6791975442e input=be97a05a788dfd83]*/
+zlib_Compress___copy___impl(compobject *self, PyTypeObject *cls)
+/*[clinic end generated code: output=074613db332cb668 input=5c0188367ab0fe64]*/
 {
-    return zlib_Compress_copy_impl(self);
+    return zlib_Compress_copy_impl(self, cls);
 }
 
 /*[clinic input]
 zlib.Compress.__deepcopy__
 
+    cls: defining_class
     memo: object
     /
 
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Compress___deepcopy__(compobject *self, PyObject *memo)
-/*[clinic end generated code: output=f47a2213282c9eb0 input=a9a8b0b40d83388e]*/
+zlib_Compress___deepcopy___impl(compobject *self, PyTypeObject *cls,
+                                PyObject *memo)
+/*[clinic end generated code: output=24b3aed785f54033 input=c90347319a514430]*/
 {
-    return zlib_Compress_copy_impl(self);
+    return zlib_Compress_copy_impl(self, cls);
 }
 
 /*[clinic input]
 zlib.Decompress.copy
 
+    cls: defining_class
+
 Return a copy of the decompression object.
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Decompress_copy_impl(compobject *self)
-/*[clinic end generated code: output=02a883a2a510c8cc input=ba6c3e96712a596b]*/
+zlib_Decompress_copy_impl(compobject *self, PyTypeObject *cls)
+/*[clinic end generated code: output=a7ddc016e1d0a781 input=20ef3aa208282ff2]*/
 {
-    compobject *retval = NULL;
-    int err;
+    zlibstate *state = PyType_GetModuleState(cls);
 
-    retval = newcompobject(_zlibstate_global->Decomptype);
+    compobject *retval = newcompobject(state->Decomptype);
     if (!retval) return NULL;
 
     /* Copy the zstream state
      * We use ENTER_ZLIB / LEAVE_ZLIB to make this thread-safe
      */
     ENTER_ZLIB(self);
-    err = inflateCopy(&retval->zst, &self->zst);
+    int err = inflateCopy(&retval->zst, &self->zst);
     switch (err) {
     case Z_OK:
         break;
@@ -1027,7 +1044,7 @@
                         "Can't allocate memory for decompression object");
         goto error;
     default:
-        zlib_error(self->zst, err, "while copying decompression object");
+        zlib_error(state, self->zst, err, "while copying decompression object");
         goto error;
     }
 
@@ -1053,28 +1070,33 @@
 
 /*[clinic input]
 zlib.Decompress.__copy__
+
+    cls: defining_class
+
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Decompress___copy___impl(compobject *self)
-/*[clinic end generated code: output=80bae8bc43498ad4 input=efcb98b5472c13d2]*/
+zlib_Decompress___copy___impl(compobject *self, PyTypeObject *cls)
+/*[clinic end generated code: output=cf1e6473744f53fa input=cc3143067b622bdf]*/
 {
-    return zlib_Decompress_copy_impl(self);
+    return zlib_Decompress_copy_impl(self, cls);
 }
 
 /*[clinic input]
 zlib.Decompress.__deepcopy__
 
+    cls: defining_class
     memo: object
     /
 
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Decompress___deepcopy__(compobject *self, PyObject *memo)
-/*[clinic end generated code: output=1f77286ab490124b input=6e99bd0ac4b9cd8b]*/
+zlib_Decompress___deepcopy___impl(compobject *self, PyTypeObject *cls,
+                                  PyObject *memo)
+/*[clinic end generated code: output=34f7b719a0c0d51b input=fc13b9c58622544e]*/
 {
-    return zlib_Decompress_copy_impl(self);
+    return zlib_Decompress_copy_impl(self, cls);
 }
 
 #endif
@@ -1082,6 +1104,7 @@
 /*[clinic input]
 zlib.Decompress.flush
 
+    cls: defining_class
     length: Py_ssize_t(c_default="DEF_BUF_SIZE") = zlib.DEF_BUF_SIZE
         the initial size of the output buffer.
     /
@@ -1090,21 +1113,30 @@
 [clinic start generated code]*/
 
 static PyObject *
-zlib_Decompress_flush_impl(compobject *self, Py_ssize_t length)
-/*[clinic end generated code: output=68c75ea127cbe654 input=427f2a05a8c2113a]*/
+zlib_Decompress_flush_impl(compobject *self, PyTypeObject *cls,
+                           Py_ssize_t length)
+/*[clinic end generated code: output=4532fc280bd0f8f2 input=42f1f4b75230e2cd]*/
 {
     int err, flush;
     Py_buffer data;
     PyObject *RetVal = NULL;
     Py_ssize_t ibuflen;
 
+    PyObject *module = PyType_GetModule(cls);
+    if (module == NULL) {
+        return NULL;
+    }
+
+    zlibstate *state = get_zlib_state(module);
+
     if (length <= 0) {
         PyErr_SetString(PyExc_ValueError, "length must be greater than zero");
         return NULL;
     }
 
-    if (PyObject_GetBuffer(self->unconsumed_tail, &data, PyBUF_SIMPLE) == -1)
+    if (PyObject_GetBuffer(self->unconsumed_tail, &data, PyBUF_SIMPLE) == -1) {
         return NULL;
+    }
 
     ENTER_ZLIB(self);
 
@@ -1131,8 +1163,9 @@
                 break;
             default:
                 if (err == Z_NEED_DICT && self->zdict != NULL) {
-                    if (set_inflate_zdict(self) < 0)
+                    if (set_inflate_zdict(state, self) < 0) {
                         goto abort;
+                    }
                     else
                         break;
                 }
@@ -1144,8 +1177,9 @@
     } while (err != Z_STREAM_END && ibuflen != 0);
 
  save:
-    if (save_unconsumed_input(self, &data, err) < 0)
+    if (save_unconsumed_input(self, &data, err) < 0) {
         goto abort;
+    }
 
     /* If at end of stream, clean up any memory allocated by zlib. */
     if (err == Z_STREAM_END) {
@@ -1153,14 +1187,15 @@
         self->is_initialised = 0;
         err = inflateEnd(&self->zst);
         if (err != Z_OK) {
-            zlib_error(self->zst, err, "while finishing decompression");
+            zlib_error(state, self->zst, err, "while finishing decompression");
             goto abort;
         }
     }
 
     if (_PyBytes_Resize(&RetVal, self->zst.next_out -
-                        (Byte *)PyBytes_AS_STRING(RetVal)) == 0)
+                        (Byte *)PyBytes_AS_STRING(RetVal)) == 0) {
         goto success;
+    }
 
  abort:
     Py_CLEAR(RetVal);
@@ -1337,9 +1372,9 @@
 "objects support decompress() and flush().");
 
 static int
-zlib_clear(PyObject *m)
+zlib_clear(PyObject *mod)
 {
-    _zlibstate *state = get_zlib_state(m);
+    zlibstate *state = get_zlib_state(mod);
     Py_CLEAR(state->Comptype);
     Py_CLEAR(state->Decomptype);
     Py_CLEAR(state->ZlibError);
@@ -1347,9 +1382,9 @@
 }
 
 static int
-zlib_traverse(PyObject *m, visitproc visit, void *arg)
+zlib_traverse(PyObject *mod, visitproc visit, void *arg)
 {
-    _zlibstate *state = get_zlib_state(m);
+    zlibstate *state = get_zlib_state(mod);
     Py_VISIT(state->Comptype);
     Py_VISIT(state->Decomptype);
     Py_VISIT(state->ZlibError);
@@ -1357,93 +1392,122 @@
 }
 
 static void
-zlib_free(void *m)
+zlib_free(void *mod)
 {
-    zlib_clear((PyObject *)m);
+    zlib_clear((PyObject *)mod);
 }
 
+static int
+zlib_exec(PyObject *mod)
+{
+    zlibstate *state = get_zlib_state(mod);
+
+    state->Comptype = (PyTypeObject *)PyType_FromModuleAndSpec(
+        mod, &Comptype_spec, NULL);
+    if (state->Comptype == NULL) {
+        return -1;
+    }
+
+    state->Decomptype = (PyTypeObject *)PyType_FromModuleAndSpec(
+        mod, &Decomptype_spec, NULL);
+    if (state->Decomptype == NULL) {
+        return -1;
+    }
+
+    state->ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
+    if (state->ZlibError == NULL) {
+        return -1;
+    }
+
+    Py_INCREF(state->ZlibError);
+    if (PyModule_AddObject(mod, "error", state->ZlibError) < 0) {
+        Py_DECREF(state->ZlibError);
+        return -1;
+    }
+
+#define ZLIB_ADD_INT_MACRO(c)                           \
+    do {                                                \
+        if ((PyModule_AddIntConstant(mod, #c, c)) < 0) {  \
+            return -1;                                  \
+        }                                               \
+    } while(0)
+
+    ZLIB_ADD_INT_MACRO(MAX_WBITS);
+    ZLIB_ADD_INT_MACRO(DEFLATED);
+    ZLIB_ADD_INT_MACRO(DEF_MEM_LEVEL);
+    ZLIB_ADD_INT_MACRO(DEF_BUF_SIZE);
+    // compression levels
+    ZLIB_ADD_INT_MACRO(Z_NO_COMPRESSION);
+    ZLIB_ADD_INT_MACRO(Z_BEST_SPEED);
+    ZLIB_ADD_INT_MACRO(Z_BEST_COMPRESSION);
+    ZLIB_ADD_INT_MACRO(Z_DEFAULT_COMPRESSION);
+    // compression strategies
+    ZLIB_ADD_INT_MACRO(Z_FILTERED);
+    ZLIB_ADD_INT_MACRO(Z_HUFFMAN_ONLY);
+#ifdef Z_RLE // 1.2.0.1
+    ZLIB_ADD_INT_MACRO(Z_RLE);
+#endif
+#ifdef Z_FIXED // 1.2.2.2
+    ZLIB_ADD_INT_MACRO(Z_FIXED);
+#endif
+    ZLIB_ADD_INT_MACRO(Z_DEFAULT_STRATEGY);
+    // allowed flush values
+    ZLIB_ADD_INT_MACRO(Z_NO_FLUSH);
+    ZLIB_ADD_INT_MACRO(Z_PARTIAL_FLUSH);
+    ZLIB_ADD_INT_MACRO(Z_SYNC_FLUSH);
+    ZLIB_ADD_INT_MACRO(Z_FULL_FLUSH);
+    ZLIB_ADD_INT_MACRO(Z_FINISH);
+#ifdef Z_BLOCK // 1.2.0.5 for inflate, 1.2.3.4 for deflate
+    ZLIB_ADD_INT_MACRO(Z_BLOCK);
+#endif
+#ifdef Z_TREES // 1.2.3.4, only for inflate
+    ZLIB_ADD_INT_MACRO(Z_TREES);
+#endif
+    PyObject *ver = PyUnicode_FromString(ZLIB_VERSION);
+    if (ver == NULL) {
+        return -1;
+    }
+
+    if (PyModule_AddObject(mod, "ZLIB_VERSION", ver) < 0) {
+        Py_DECREF(ver);
+        return -1;
+    }
+
+    ver = PyUnicode_FromString(zlibVersion());
+    if (ver == NULL) {
+        return -1;
+    }
+
+    if (PyModule_AddObject(mod, "ZLIB_RUNTIME_VERSION", ver) < 0) {
+        Py_DECREF(ver);
+        return -1;
+    }
+
+    if (PyModule_AddStringConstant(mod, "__version__", "1.0") < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static PyModuleDef_Slot zlib_slots[] = {
+    {Py_mod_exec, zlib_exec},
+    {0, NULL}
+};
+
 static struct PyModuleDef zlibmodule = {
-        PyModuleDef_HEAD_INIT,
-        "zlib",
-        zlib_module_documentation,
-        sizeof(_zlibstate),
-        zlib_methods,
-        NULL,
-        zlib_traverse,
-        zlib_clear,
-        zlib_free,
+    PyModuleDef_HEAD_INIT,
+    .m_name = "zlib",
+    .m_doc = zlib_module_documentation,
+    .m_size = sizeof(zlibstate),
+    .m_methods = zlib_methods,
+    .m_slots = zlib_slots,
+    .m_traverse = zlib_traverse,
+    .m_clear = zlib_clear,
+    .m_free = zlib_free,
 };
 
 PyMODINIT_FUNC
 PyInit_zlib(void)
 {
-    PyObject *m, *ver;
-    m = PyState_FindModule(&zlibmodule);
-    if (m != NULL) {
-        Py_INCREF(m);
-        return m;
-    }
-    m = PyModule_Create(&zlibmodule);
-    if (m == NULL)
-        return NULL;
-
-    PyTypeObject *Comptype = (PyTypeObject *)PyType_FromSpec(&Comptype_spec);
-    if (Comptype == NULL)
-        return NULL;
-    get_zlib_state(m)->Comptype = Comptype;
-
-    PyTypeObject *Decomptype = (PyTypeObject *)PyType_FromSpec(&Decomptype_spec);
-    if (Decomptype == NULL)
-        return NULL;
-    get_zlib_state(m)->Decomptype = Decomptype;
-
-    PyObject *ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
-    if (ZlibError != NULL) {
-        Py_INCREF(ZlibError);
-        PyModule_AddObject(m, "error", ZlibError);
-        get_zlib_state(m)->ZlibError = ZlibError;
-    }
-    PyModule_AddIntMacro(m, MAX_WBITS);
-    PyModule_AddIntMacro(m, DEFLATED);
-    PyModule_AddIntMacro(m, DEF_MEM_LEVEL);
-    PyModule_AddIntMacro(m, DEF_BUF_SIZE);
-    // compression levels
-    PyModule_AddIntMacro(m, Z_NO_COMPRESSION);
-    PyModule_AddIntMacro(m, Z_BEST_SPEED);
-    PyModule_AddIntMacro(m, Z_BEST_COMPRESSION);
-    PyModule_AddIntMacro(m, Z_DEFAULT_COMPRESSION);
-    // compression strategies
-    PyModule_AddIntMacro(m, Z_FILTERED);
-    PyModule_AddIntMacro(m, Z_HUFFMAN_ONLY);
-#ifdef Z_RLE // 1.2.0.1
-    PyModule_AddIntMacro(m, Z_RLE);
-#endif
-#ifdef Z_FIXED // 1.2.2.2
-    PyModule_AddIntMacro(m, Z_FIXED);
-#endif
-    PyModule_AddIntMacro(m, Z_DEFAULT_STRATEGY);
-    // allowed flush values
-    PyModule_AddIntMacro(m, Z_NO_FLUSH);
-    PyModule_AddIntMacro(m, Z_PARTIAL_FLUSH);
-    PyModule_AddIntMacro(m, Z_SYNC_FLUSH);
-    PyModule_AddIntMacro(m, Z_FULL_FLUSH);
-    PyModule_AddIntMacro(m, Z_FINISH);
-#ifdef Z_BLOCK // 1.2.0.5 for inflate, 1.2.3.4 for deflate
-    PyModule_AddIntMacro(m, Z_BLOCK);
-#endif
-#ifdef Z_TREES // 1.2.3.4, only for inflate
-    PyModule_AddIntMacro(m, Z_TREES);
-#endif
-    ver = PyUnicode_FromString(ZLIB_VERSION);
-    if (ver != NULL)
-        PyModule_AddObject(m, "ZLIB_VERSION", ver);
-
-    ver = PyUnicode_FromString(zlibVersion());
-    if (ver != NULL)
-        PyModule_AddObject(m, "ZLIB_RUNTIME_VERSION", ver);
-
-    PyModule_AddStringConstant(m, "__version__", "1.0");
-
-    PyState_AddModule(m, &zlibmodule);
-    return m;
+    return PyModuleDef_Init(&zlibmodule);
 }