diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
deleted file mode 100644
index decd6ae3e553f23..000000000000000
--- a/Modules/_collectionsmodule.c
+++ /dev/null
@@ -1,2424 +0,0 @@
-#include "Python.h"
-#include "structmember.h"
-
-#ifdef STDC_HEADERS
-#include <stddef.h>
-#else
-#include <sys/types.h>          /* For size_t */
-#endif
-
-/* collections module implementation of a deque() datatype
-   Written and maintained by Raymond D. Hettinger <python@rcn.com>
-*/
-
-/* The block length may be set to any number over 1.  Larger numbers
- * reduce the number of calls to the memory allocator, give faster
- * indexing and rotation, and reduce the link to data overhead ratio.
- * Making the block length a power of two speeds-up the modulo
- * and division calculations in deque_item() and deque_ass_item().
- */
-
-#define BLOCKLEN 64
-#define CENTER ((BLOCKLEN - 1) / 2)
-
-/* Data for deque objects is stored in a doubly-linked list of fixed
- * length blocks.  This assures that appends or pops never move any
- * other data elements besides the one being appended or popped.
- *
- * Another advantage is that it completely avoids use of realloc(),
- * resulting in more predictable performance.
- *
- * Textbook implementations of doubly-linked lists store one datum
- * per link, but that gives them a 200% memory overhead (a prev and
- * next link for each datum) and it costs one malloc() call per data
- * element.  By using fixed-length blocks, the link to data ratio is
- * significantly improved and there are proportionally fewer calls
- * to malloc() and free().  The data blocks of consecutive pointers
- * also improve cache locality.
- *
- * The list of blocks is never empty, so d.leftblock and d.rightblock
- * are never equal to NULL.  The list is not circular.
- *
- * A deque d's first element is at d.leftblock[leftindex]
- * and its last element is at d.rightblock[rightindex].
- *
- * Unlike Python slice indices, these indices are inclusive on both
- * ends.  This makes the algorithms for left and right operations
- * more symmetrical and it simplifies the design.
- *
- * The indices, d.leftindex and d.rightindex are always in the range:
- *     0 <= index < BLOCKLEN
- *
- * And their exact relationship is:
- *     (d.leftindex + d.len - 1) % BLOCKLEN == d.rightindex
- *
- * Whenever d.leftblock == d.rightblock, then:
- *     d.leftindex + d.len - 1 == d.rightindex
- *
- * However, when d.leftblock != d.rightblock, the d.leftindex and
- * d.rightindex become indices into distinct blocks and either may
- * be larger than the other.
- *
- * Empty deques have:
- *     d.len == 0
- *     d.leftblock == d.rightblock
- *     d.leftindex == CENTER + 1
- *     d.rightindex == CENTER
- *
- * Checking for d.len == 0 is the intended way to see whether d is empty.
- */
-
-typedef struct BLOCK {
-    struct BLOCK *leftlink;
-    PyObject *data[BLOCKLEN];
-    struct BLOCK *rightlink;
-} block;
-
-typedef struct {
-    PyObject_VAR_HEAD
-    block *leftblock;
-    block *rightblock;
-    Py_ssize_t leftindex;       /* 0 <= leftindex < BLOCKLEN */
-    Py_ssize_t rightindex;      /* 0 <= rightindex < BLOCKLEN */
-    size_t state;               /* incremented whenever the indices move */
-    Py_ssize_t maxlen;          /* maxlen is -1 for unbounded deques */
-    PyObject *weakreflist;
-} dequeobject;
-
-static PyTypeObject deque_type;
-
-/* For debug builds, add error checking to track the endpoints
- * in the chain of links.  The goal is to make sure that link
- * assignments only take place at endpoints so that links already
- * in use do not get overwritten.
- *
- * CHECK_END should happen before each assignment to a block's link field.
- * MARK_END should happen whenever a link field becomes a new endpoint.
- * This happens when new blocks are added or whenever an existing
- * block is freed leaving another existing block as the new endpoint.
- */
-
-#ifndef NDEBUG
-#define MARK_END(link)  link = NULL;
-#define CHECK_END(link) assert(link == NULL);
-#define CHECK_NOT_END(link) assert(link != NULL);
-#else
-#define MARK_END(link)
-#define CHECK_END(link)
-#define CHECK_NOT_END(link)
-#endif
-
-/* A simple freelisting scheme is used to minimize calls to the memory
-   allocator.  It accommodates common use cases where new blocks are being
-   added at about the same rate as old blocks are being freed.
- */
-
-#define MAXFREEBLOCKS 16
-static Py_ssize_t numfreeblocks = 0;
-static block *freeblocks[MAXFREEBLOCKS];
-
-static block *
-newblock(void) {
-    block *b;
-    if (numfreeblocks) {
-        numfreeblocks--;
-        return freeblocks[numfreeblocks];
-    }
-    b = PyMem_Malloc(sizeof(block));
-    if (b != NULL) {
-        return b;
-    }
-    PyErr_NoMemory();
-    return NULL;
-}
-
-static void
-freeblock(block *b)
-{
-    if (numfreeblocks < MAXFREEBLOCKS) {
-        freeblocks[numfreeblocks] = b;
-        numfreeblocks++;
-    } else {
-        PyMem_Free(b);
-    }
-}
-
-static PyObject *
-deque_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    dequeobject *deque;
-    block *b;
-
-    /* create dequeobject structure */
-    deque = (dequeobject *)type->tp_alloc(type, 0);
-    if (deque == NULL)
-        return NULL;
-
-    b = newblock();
-    if (b == NULL) {
-        Py_DECREF(deque);
-        return NULL;
-    }
-    MARK_END(b->leftlink);
-    MARK_END(b->rightlink);
-
-    assert(BLOCKLEN >= 2);
-    Py_SIZE(deque) = 0;
-    deque->leftblock = b;
-    deque->rightblock = b;
-    deque->leftindex = CENTER + 1;
-    deque->rightindex = CENTER;
-    deque->state = 0;
-    deque->maxlen = -1;
-    deque->weakreflist = NULL;
-
-    return (PyObject *)deque;
-}
-
-static PyObject *
-deque_pop(dequeobject *deque, PyObject *unused)
-{
-    PyObject *item;
-    block *prevblock;
-
-    if (Py_SIZE(deque) == 0) {
-        PyErr_SetString(PyExc_IndexError, "pop from an empty deque");
-        return NULL;
-    }
-    item = deque->rightblock->data[deque->rightindex];
-    deque->rightindex--;
-    Py_SIZE(deque)--;
-    deque->state++;
-
-    if (deque->rightindex < 0) {
-        if (Py_SIZE(deque)) {
-            prevblock = deque->rightblock->leftlink;
-            assert(deque->leftblock != deque->rightblock);
-            freeblock(deque->rightblock);
-            CHECK_NOT_END(prevblock);
-            MARK_END(prevblock->rightlink);
-            deque->rightblock = prevblock;
-            deque->rightindex = BLOCKLEN - 1;
-        } else {
-            assert(deque->leftblock == deque->rightblock);
-            assert(deque->leftindex == deque->rightindex+1);
-            /* re-center instead of freeing a block */
-            deque->leftindex = CENTER + 1;
-            deque->rightindex = CENTER;
-        }
-    }
-    return item;
-}
-
-PyDoc_STRVAR(pop_doc, "Remove and return the rightmost element.");
-
-static PyObject *
-deque_popleft(dequeobject *deque, PyObject *unused)
-{
-    PyObject *item;
-    block *prevblock;
-
-    if (Py_SIZE(deque) == 0) {
-        PyErr_SetString(PyExc_IndexError, "pop from an empty deque");
-        return NULL;
-    }
-    assert(deque->leftblock != NULL);
-    item = deque->leftblock->data[deque->leftindex];
-    deque->leftindex++;
-    Py_SIZE(deque)--;
-    deque->state++;
-
-    if (deque->leftindex == BLOCKLEN) {
-        if (Py_SIZE(deque)) {
-            assert(deque->leftblock != deque->rightblock);
-            prevblock = deque->leftblock->rightlink;
-            freeblock(deque->leftblock);
-            CHECK_NOT_END(prevblock);
-            MARK_END(prevblock->leftlink);
-            deque->leftblock = prevblock;
-            deque->leftindex = 0;
-        } else {
-            assert(deque->leftblock == deque->rightblock);
-            assert(deque->leftindex == deque->rightindex+1);
-            /* re-center instead of freeing a block */
-            deque->leftindex = CENTER + 1;
-            deque->rightindex = CENTER;
-        }
-    }
-    return item;
-}
-
-PyDoc_STRVAR(popleft_doc, "Remove and return the leftmost element.");
-
-/* The deque's size limit is d.maxlen.  The limit can be zero or positive.
- * If there is no limit, then d.maxlen == -1.
- *
- * After an item is added to a deque, we check to see if the size has
- * grown past the limit. If it has, we get the size back down to the limit
- * by popping an item off of the opposite end.  The methods that can
- * trigger this are append(), appendleft(), extend(), and extendleft().
- *
- * The macro to check whether a deque needs to be trimmed uses a single
- * unsigned test that returns true whenever 0 <= maxlen < Py_SIZE(deque).
- */
-
-#define NEEDS_TRIM(deque, maxlen) ((size_t)(maxlen) < (size_t)(Py_SIZE(deque)))
-
-static int
-deque_append_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen)
-{
-    if (deque->rightindex == BLOCKLEN - 1) {
-        block *b = newblock();
-        if (b == NULL)
-            return -1;
-        b->leftlink = deque->rightblock;
-        CHECK_END(deque->rightblock->rightlink);
-        deque->rightblock->rightlink = b;
-        deque->rightblock = b;
-        MARK_END(b->rightlink);
-        deque->rightindex = -1;
-    }
-    Py_SIZE(deque)++;
-    deque->rightindex++;
-    deque->rightblock->data[deque->rightindex] = item;
-    if (NEEDS_TRIM(deque, maxlen)) {
-        PyObject *olditem = deque_popleft(deque, NULL);
-        Py_DECREF(olditem);
-    } else {
-        deque->state++;
-    }
-    return 0;
-}
-
-static PyObject *
-deque_append(dequeobject *deque, PyObject *item)
-{
-    Py_INCREF(item);
-    if (deque_append_internal(deque, item, deque->maxlen) < 0)
-        return NULL;
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(append_doc, "Add an element to the right side of the deque.");
-
-static int
-deque_appendleft_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen)
-{
-    if (deque->leftindex == 0) {
-        block *b = newblock();
-        if (b == NULL)
-            return -1;
-        b->rightlink = deque->leftblock;
-        CHECK_END(deque->leftblock->leftlink);
-        deque->leftblock->leftlink = b;
-        deque->leftblock = b;
-        MARK_END(b->leftlink);
-        deque->leftindex = BLOCKLEN;
-    }
-    Py_SIZE(deque)++;
-    deque->leftindex--;
-    deque->leftblock->data[deque->leftindex] = item;
-    if (NEEDS_TRIM(deque, deque->maxlen)) {
-        PyObject *olditem = deque_pop(deque, NULL);
-        Py_DECREF(olditem);
-    } else {
-        deque->state++;
-    }
-    return 0;
-}
-
-static PyObject *
-deque_appendleft(dequeobject *deque, PyObject *item)
-{
-    Py_INCREF(item);
-    if (deque_appendleft_internal(deque, item, deque->maxlen) < 0)
-        return NULL;
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(appendleft_doc, "Add an element to the left side of the deque.");
-
-static PyObject*
-finalize_iterator(PyObject *it)
-{
-    if (PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_StopIteration))
-            PyErr_Clear();
-        else {
-            Py_DECREF(it);
-            return NULL;
-        }
-    }
-    Py_DECREF(it);
-    Py_RETURN_NONE;
-}
-
-/* Run an iterator to exhaustion.  Shortcut for
-   the extend/extendleft methods when maxlen == 0. */
-static PyObject*
-consume_iterator(PyObject *it)
-{
-    PyObject *(*iternext)(PyObject *);
-    PyObject *item;
-
-    iternext = *Py_TYPE(it)->tp_iternext;
-    while ((item = iternext(it)) != NULL) {
-        Py_DECREF(item);
-    }
-    return finalize_iterator(it);
-}
-
-static PyObject *
-deque_extend(dequeobject *deque, PyObject *iterable)
-{
-    PyObject *it, *item;
-    PyObject *(*iternext)(PyObject *);
-    Py_ssize_t maxlen = deque->maxlen;
-
-    /* Handle case where id(deque) == id(iterable) */
-    if ((PyObject *)deque == iterable) {
-        PyObject *result;
-        PyObject *s = PySequence_List(iterable);
-        if (s == NULL)
-            return NULL;
-        result = deque_extend(deque, s);
-        Py_DECREF(s);
-        return result;
-    }
-
-    it = PyObject_GetIter(iterable);
-    if (it == NULL)
-        return NULL;
-
-    if (maxlen == 0)
-        return consume_iterator(it);
-
-    /* Space saving heuristic.  Start filling from the left */
-    if (Py_SIZE(deque) == 0) {
-        assert(deque->leftblock == deque->rightblock);
-        assert(deque->leftindex == deque->rightindex+1);
-        deque->leftindex = 1;
-        deque->rightindex = 0;
-    }
-
-    iternext = *Py_TYPE(it)->tp_iternext;
-    while ((item = iternext(it)) != NULL) {
-        if (deque->rightindex == BLOCKLEN - 1) {
-            block *b = newblock();
-            if (b == NULL) {
-                Py_DECREF(item);
-                Py_DECREF(it);
-                return NULL;
-            }
-            b->leftlink = deque->rightblock;
-            CHECK_END(deque->rightblock->rightlink);
-            deque->rightblock->rightlink = b;
-            deque->rightblock = b;
-            MARK_END(b->rightlink);
-            deque->rightindex = -1;
-        }
-        Py_SIZE(deque)++;
-        deque->rightindex++;
-        deque->rightblock->data[deque->rightindex] = item;
-        if (NEEDS_TRIM(deque, maxlen)) {
-            PyObject *olditem = deque_popleft(deque, NULL);
-            Py_DECREF(olditem);
-        } else {
-            deque->state++;
-        }
-    }
-    return finalize_iterator(it);
-}
-
-PyDoc_STRVAR(extend_doc,
-"Extend the right side of the deque with elements from the iterable");
-
-static PyObject *
-deque_extendleft(dequeobject *deque, PyObject *iterable)
-{
-    PyObject *it, *item;
-    PyObject *(*iternext)(PyObject *);
-    Py_ssize_t maxlen = deque->maxlen;
-
-    /* Handle case where id(deque) == id(iterable) */
-    if ((PyObject *)deque == iterable) {
-        PyObject *result;
-        PyObject *s = PySequence_List(iterable);
-        if (s == NULL)
-            return NULL;
-        result = deque_extendleft(deque, s);
-        Py_DECREF(s);
-        return result;
-    }
-
-    it = PyObject_GetIter(iterable);
-    if (it == NULL)
-        return NULL;
-
-    if (maxlen == 0)
-        return consume_iterator(it);
-
-    /* Space saving heuristic.  Start filling from the right */
-    if (Py_SIZE(deque) == 0) {
-        assert(deque->leftblock == deque->rightblock);
-        assert(deque->leftindex == deque->rightindex+1);
-        deque->leftindex = BLOCKLEN - 1;
-        deque->rightindex = BLOCKLEN - 2;
-    }
-
-    iternext = *Py_TYPE(it)->tp_iternext;
-    while ((item = iternext(it)) != NULL) {
-        if (deque->leftindex == 0) {
-            block *b = newblock();
-            if (b == NULL) {
-                Py_DECREF(item);
-                Py_DECREF(it);
-                return NULL;
-            }
-            b->rightlink = deque->leftblock;
-            CHECK_END(deque->leftblock->leftlink);
-            deque->leftblock->leftlink = b;
-            deque->leftblock = b;
-            MARK_END(b->leftlink);
-            deque->leftindex = BLOCKLEN;
-        }
-        Py_SIZE(deque)++;
-        deque->leftindex--;
-        deque->leftblock->data[deque->leftindex] = item;
-        if (NEEDS_TRIM(deque, maxlen)) {
-            PyObject *olditem = deque_pop(deque, NULL);
-            Py_DECREF(olditem);
-        } else {
-            deque->state++;
-        }
-    }
-    return finalize_iterator(it);
-}
-
-PyDoc_STRVAR(extendleft_doc,
-"Extend the left side of the deque with elements from the iterable");
-
-static PyObject *
-deque_inplace_concat(dequeobject *deque, PyObject *other)
-{
-    PyObject *result;
-
-    result = deque_extend(deque, other);
-    if (result == NULL)
-        return result;
-    Py_INCREF(deque);
-    Py_DECREF(result);
-    return (PyObject *)deque;
-}
-
-static PyObject *
-deque_copy(PyObject *deque)
-{
-    PyObject *result;
-    dequeobject *old_deque = (dequeobject *)deque;
-    if (Py_TYPE(deque) == &deque_type) {
-        dequeobject *new_deque;
-        PyObject *rv;
-
-        new_deque = (dequeobject *)deque_new(&deque_type, (PyObject *)NULL, (PyObject *)NULL);
-        if (new_deque == NULL)
-            return NULL;
-        new_deque->maxlen = old_deque->maxlen;
-        /* Fast path for the deque_repeat() common case where len(deque) == 1 */
-        if (Py_SIZE(deque) == 1) {
-            PyObject *item = old_deque->leftblock->data[old_deque->leftindex];
-            rv = deque_append(new_deque, item);
-        } else {
-            rv = deque_extend(new_deque, deque);
-        }
-        if (rv != NULL) {
-            Py_DECREF(rv);
-            return (PyObject *)new_deque;
-        }
-        Py_DECREF(new_deque);
-        return NULL;
-    }
-    if (old_deque->maxlen < 0)
-        result = PyObject_CallFunctionObjArgs((PyObject *)(Py_TYPE(deque)),
-                                              deque, NULL);
-    else
-        result = PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "Oi",
-                                       deque, old_deque->maxlen, NULL);
-    if (result != NULL && !PyObject_TypeCheck(result, &deque_type)) {
-        PyErr_Format(PyExc_TypeError,
-                     "%.200s() must return a deque, not %.200s",
-                     Py_TYPE(deque)->tp_name, Py_TYPE(result)->tp_name);
-        Py_DECREF(result);
-        return NULL;
-    }
-    return result;
-}
-
-PyDoc_STRVAR(copy_doc, "Return a shallow copy of a deque.");
-
-static PyObject *
-deque_concat(dequeobject *deque, PyObject *other)
-{
-    PyObject *new_deque, *result;
-    int rv;
-
-    rv = PyObject_IsInstance(other, (PyObject *)&deque_type);
-    if (rv <= 0) {
-        if (rv == 0) {
-            PyErr_Format(PyExc_TypeError,
-                         "can only concatenate deque (not \"%.200s\") to deque",
-                         other->ob_type->tp_name);
-        }
-        return NULL;
-    }
-
-    new_deque = deque_copy((PyObject *)deque);
-    if (new_deque == NULL)
-        return NULL;
-    result = deque_extend((dequeobject *)new_deque, other);
-    if (result == NULL) {
-        Py_DECREF(new_deque);
-        return NULL;
-    }
-    Py_DECREF(result);
-    return new_deque;
-}
-
-static int
-deque_clear(dequeobject *deque)
-{
-    block *b;
-    block *prevblock;
-    block *leftblock;
-    Py_ssize_t leftindex;
-    Py_ssize_t n, m;
-    PyObject *item;
-    PyObject **itemptr, **limit;
-
-    if (Py_SIZE(deque) == 0)
-        return 0;
-
-    /* During the process of clearing a deque, decrefs can cause the
-       deque to mutate.  To avoid fatal confusion, we have to make the
-       deque empty before clearing the blocks and never refer to
-       anything via deque->ref while clearing.  (This is the same
-       technique used for clearing lists, sets, and dicts.)
-
-       Making the deque empty requires allocating a new empty block.  In
-       the unlikely event that memory is full, we fall back to an
-       alternate method that doesn't require a new block.  Repeating
-       pops in a while-loop is slower, possibly re-entrant (and a clever
-       adversary could cause it to never terminate).
-    */
-
-    b = newblock();
-    if (b == NULL) {
-        PyErr_Clear();
-        goto alternate_method;
-    }
-
-    /* Remember the old size, leftblock, and leftindex */
-    n = Py_SIZE(deque);
-    leftblock = deque->leftblock;
-    leftindex = deque->leftindex;
-
-    /* Set the deque to be empty using the newly allocated block */
-    MARK_END(b->leftlink);
-    MARK_END(b->rightlink);
-    Py_SIZE(deque) = 0;
-    deque->leftblock = b;
-    deque->rightblock = b;
-    deque->leftindex = CENTER + 1;
-    deque->rightindex = CENTER;
-    deque->state++;
-
-    /* Now the old size, leftblock, and leftindex are disconnected from
-       the empty deque and we can use them to decref the pointers.
-    */
-    m = (BLOCKLEN - leftindex > n) ? n : BLOCKLEN - leftindex;
-    itemptr = &leftblock->data[leftindex];
-    limit = itemptr + m;
-    n -= m;
-    while (1) {
-        if (itemptr == limit) {
-            if (n == 0)
-                break;
-            CHECK_NOT_END(leftblock->rightlink);
-            prevblock = leftblock;
-            leftblock = leftblock->rightlink;
-            m = (n > BLOCKLEN) ? BLOCKLEN : n;
-            itemptr = leftblock->data;
-            limit = itemptr + m;
-            n -= m;
-            freeblock(prevblock);
-        }
-        item = *(itemptr++);
-        Py_DECREF(item);
-    }
-    CHECK_END(leftblock->rightlink);
-    freeblock(leftblock);
-    return 0;
-
-  alternate_method:
-    while (Py_SIZE(deque)) {
-        item = deque_pop(deque, NULL);
-        assert (item != NULL);
-        Py_DECREF(item);
-    }
-    return 0;
-}
-
-static PyObject *
-deque_clearmethod(dequeobject *deque)
-{
-    deque_clear(deque);
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(clear_doc, "Remove all elements from the deque.");
-
-static PyObject *
-deque_inplace_repeat(dequeobject *deque, Py_ssize_t n)
-{
-    Py_ssize_t i, m, size;
-    PyObject *seq;
-    PyObject *rv;
-
-    size = Py_SIZE(deque);
-    if (size == 0 || n == 1) {
-        Py_INCREF(deque);
-        return (PyObject *)deque;
-    }
-
-    if (n <= 0) {
-        deque_clear(deque);
-        Py_INCREF(deque);
-        return (PyObject *)deque;
-    }
-
-    if (size == 1) {
-        /* common case, repeating a single element */
-        PyObject *item = deque->leftblock->data[deque->leftindex];
-
-        if (deque->maxlen >= 0 && n > deque->maxlen)
-            n = deque->maxlen;
-
-        deque->state++;
-        for (i = 0 ; i < n-1 ; ) {
-            if (deque->rightindex == BLOCKLEN - 1) {
-                block *b = newblock();
-                if (b == NULL) {
-                    Py_SIZE(deque) += i;
-                    return NULL;
-                }
-                b->leftlink = deque->rightblock;
-                CHECK_END(deque->rightblock->rightlink);
-                deque->rightblock->rightlink = b;
-                deque->rightblock = b;
-                MARK_END(b->rightlink);
-                deque->rightindex = -1;
-            }
-            m = n - 1 - i;
-            if (m > BLOCKLEN - 1 - deque->rightindex)
-                m = BLOCKLEN - 1 - deque->rightindex;
-            i += m;
-            while (m--) {
-                deque->rightindex++;
-                Py_INCREF(item);
-                deque->rightblock->data[deque->rightindex] = item;
-            }
-        }
-        Py_SIZE(deque) += i;
-        Py_INCREF(deque);
-        return (PyObject *)deque;
-    }
-
-    if ((size_t)size > PY_SSIZE_T_MAX / (size_t)n) {
-        return PyErr_NoMemory();
-    }
-
-    seq = PySequence_List((PyObject *)deque);
-    if (seq == NULL)
-        return seq;
-
-    /* Reduce the number of repetitions when maxlen would be exceeded */
-    if (deque->maxlen >= 0 && n * size > deque->maxlen)
-        n = (deque->maxlen + size - 1) / size;
-
-    for (i = 0 ; i < n-1 ; i++) {
-        rv = deque_extend(deque, seq);
-        if (rv == NULL) {
-            Py_DECREF(seq);
-            return NULL;
-        }
-        Py_DECREF(rv);
-    }
-    Py_INCREF(deque);
-    Py_DECREF(seq);
-    return (PyObject *)deque;
-}
-
-static PyObject *
-deque_repeat(dequeobject *deque, Py_ssize_t n)
-{
-    dequeobject *new_deque;
-    PyObject *rv;
-
-    new_deque = (dequeobject *)deque_copy((PyObject *) deque);
-    if (new_deque == NULL)
-        return NULL;
-    rv = deque_inplace_repeat(new_deque, n);
-    Py_DECREF(new_deque);
-    return rv;
-}
-
-/* The rotate() method is part of the public API and is used internally
-as a primitive for other methods.
-
-Rotation by 1 or -1 is a common case, so any optimizations for high
-volume rotations should take care not to penalize the common case.
-
-Conceptually, a rotate by one is equivalent to a pop on one side and an
-append on the other.  However, a pop/append pair is unnecessarily slow
-because it requires an incref/decref pair for an object located randomly
-in memory.  It is better to just move the object pointer from one block
-to the next without changing the reference count.
-
-When moving batches of pointers, it is tempting to use memcpy() but that
-proved to be slower than a simple loop for a variety of reasons.
-Memcpy() cannot know in advance that we're copying pointers instead of
-bytes, that the source and destination are pointer aligned and
-non-overlapping, that moving just one pointer is a common case, that we
-never need to move more than BLOCKLEN pointers, and that at least one
-pointer is always moved.
-
-For high volume rotations, newblock() and freeblock() are never called
-more than once.  Previously emptied blocks are immediately reused as a
-destination block.  If a block is left-over at the end, it is freed.
-*/
-
-static int
-_deque_rotate(dequeobject *deque, Py_ssize_t n)
-{
-    block *b = NULL;
-    block *leftblock = deque->leftblock;
-    block *rightblock = deque->rightblock;
-    Py_ssize_t leftindex = deque->leftindex;
-    Py_ssize_t rightindex = deque->rightindex;
-    Py_ssize_t len=Py_SIZE(deque), halflen=len>>1;
-    int rv = -1;
-
-    if (len <= 1)
-        return 0;
-    if (n > halflen || n < -halflen) {
-        n %= len;
-        if (n > halflen)
-            n -= len;
-        else if (n < -halflen)
-            n += len;
-    }
-    assert(len > 1);
-    assert(-halflen <= n && n <= halflen);
-
-    deque->state++;
-    while (n > 0) {
-        if (leftindex == 0) {
-            if (b == NULL) {
-                b = newblock();
-                if (b == NULL)
-                    goto done;
-            }
-            b->rightlink = leftblock;
-            CHECK_END(leftblock->leftlink);
-            leftblock->leftlink = b;
-            leftblock = b;
-            MARK_END(b->leftlink);
-            leftindex = BLOCKLEN;
-            b = NULL;
-        }
-        assert(leftindex > 0);
-        {
-            PyObject **src, **dest;
-            Py_ssize_t m = n;
-
-            if (m > rightindex + 1)
-                m = rightindex + 1;
-            if (m > leftindex)
-                m = leftindex;
-            assert (m > 0 && m <= len);
-            rightindex -= m;
-            leftindex -= m;
-            src = &rightblock->data[rightindex + 1];
-            dest = &leftblock->data[leftindex];
-            n -= m;
-            do {
-                *(dest++) = *(src++);
-            } while (--m);
-        }
-        if (rightindex < 0) {
-            assert(leftblock != rightblock);
-            assert(b == NULL);
-            b = rightblock;
-            CHECK_NOT_END(rightblock->leftlink);
-            rightblock = rightblock->leftlink;
-            MARK_END(rightblock->rightlink);
-            rightindex = BLOCKLEN - 1;
-        }
-    }
-    while (n < 0) {
-        if (rightindex == BLOCKLEN - 1) {
-            if (b == NULL) {
-                b = newblock();
-                if (b == NULL)
-                    goto done;
-            }
-            b->leftlink = rightblock;
-            CHECK_END(rightblock->rightlink);
-            rightblock->rightlink = b;
-            rightblock = b;
-            MARK_END(b->rightlink);
-            rightindex = -1;
-            b = NULL;
-        }
-        assert (rightindex < BLOCKLEN - 1);
-        {
-            PyObject **src, **dest;
-            Py_ssize_t m = -n;
-
-            if (m > BLOCKLEN - leftindex)
-                m = BLOCKLEN - leftindex;
-            if (m > BLOCKLEN - 1 - rightindex)
-                m = BLOCKLEN - 1 - rightindex;
-            assert (m > 0 && m <= len);
-            src = &leftblock->data[leftindex];
-            dest = &rightblock->data[rightindex + 1];
-            leftindex += m;
-            rightindex += m;
-            n += m;
-            do {
-                *(dest++) = *(src++);
-            } while (--m);
-        }
-        if (leftindex == BLOCKLEN) {
-            assert(leftblock != rightblock);
-            assert(b == NULL);
-            b = leftblock;
-            CHECK_NOT_END(leftblock->rightlink);
-            leftblock = leftblock->rightlink;
-            MARK_END(leftblock->leftlink);
-            leftindex = 0;
-        }
-    }
-    rv = 0;
-done:
-    if (b != NULL)
-        freeblock(b);
-    deque->leftblock = leftblock;
-    deque->rightblock = rightblock;
-    deque->leftindex = leftindex;
-    deque->rightindex = rightindex;
-
-    return rv;
-}
-
-static PyObject *
-deque_rotate(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs)
-{
-    Py_ssize_t n=1;
-
-    if (!_PyArg_ParseStack(args, nargs, "|n:rotate", &n)) {
-        return NULL;
-    }
-
-    if (!_deque_rotate(deque, n))
-        Py_RETURN_NONE;
-    return NULL;
-}
-
-PyDoc_STRVAR(rotate_doc,
-"Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.");
-
-static PyObject *
-deque_reverse(dequeobject *deque, PyObject *unused)
-{
-    block *leftblock = deque->leftblock;
-    block *rightblock = deque->rightblock;
-    Py_ssize_t leftindex = deque->leftindex;
-    Py_ssize_t rightindex = deque->rightindex;
-    Py_ssize_t n = Py_SIZE(deque) >> 1;
-    PyObject *tmp;
-
-    while (--n >= 0) {
-        /* Validate that pointers haven't met in the middle */
-        assert(leftblock != rightblock || leftindex < rightindex);
-        CHECK_NOT_END(leftblock);
-        CHECK_NOT_END(rightblock);
-
-        /* Swap */
-        tmp = leftblock->data[leftindex];
-        leftblock->data[leftindex] = rightblock->data[rightindex];
-        rightblock->data[rightindex] = tmp;
-
-        /* Advance left block/index pair */
-        leftindex++;
-        if (leftindex == BLOCKLEN) {
-            leftblock = leftblock->rightlink;
-            leftindex = 0;
-        }
-
-        /* Step backwards with the right block/index pair */
-        rightindex--;
-        if (rightindex < 0) {
-            rightblock = rightblock->leftlink;
-            rightindex = BLOCKLEN - 1;
-        }
-    }
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(reverse_doc,
-"D.reverse() -- reverse *IN PLACE*");
-
-static PyObject *
-deque_count(dequeobject *deque, PyObject *v)
-{
-    block *b = deque->leftblock;
-    Py_ssize_t index = deque->leftindex;
-    Py_ssize_t n = Py_SIZE(deque);
-    Py_ssize_t count = 0;
-    size_t start_state = deque->state;
-    PyObject *item;
-    int cmp;
-
-    while (--n >= 0) {
-        CHECK_NOT_END(b);
-        item = b->data[index];
-        cmp = PyObject_RichCompareBool(item, v, Py_EQ);
-        if (cmp < 0)
-            return NULL;
-        count += cmp;
-
-        if (start_state != deque->state) {
-            PyErr_SetString(PyExc_RuntimeError,
-                            "deque mutated during iteration");
-            return NULL;
-        }
-
-        /* Advance left block/index pair */
-        index++;
-        if (index == BLOCKLEN) {
-            b = b->rightlink;
-            index = 0;
-        }
-    }
-    return PyLong_FromSsize_t(count);
-}
-
-PyDoc_STRVAR(count_doc,
-"D.count(value) -> integer -- return number of occurrences of value");
-
-static int
-deque_contains(dequeobject *deque, PyObject *v)
-{
-    block *b = deque->leftblock;
-    Py_ssize_t index = deque->leftindex;
-    Py_ssize_t n = Py_SIZE(deque);
-    size_t start_state = deque->state;
-    PyObject *item;
-    int cmp;
-
-    while (--n >= 0) {
-        CHECK_NOT_END(b);
-        item = b->data[index];
-        cmp = PyObject_RichCompareBool(item, v, Py_EQ);
-        if (cmp) {
-            return cmp;
-        }
-        if (start_state != deque->state) {
-            PyErr_SetString(PyExc_RuntimeError,
-                            "deque mutated during iteration");
-            return -1;
-        }
-        index++;
-        if (index == BLOCKLEN) {
-            b = b->rightlink;
-            index = 0;
-        }
-    }
-    return 0;
-}
-
-static Py_ssize_t
-deque_len(dequeobject *deque)
-{
-    return Py_SIZE(deque);
-}
-
-static PyObject *
-deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs)
-{
-    Py_ssize_t i, n, start=0, stop=Py_SIZE(deque);
-    PyObject *v, *item;
-    block *b = deque->leftblock;
-    Py_ssize_t index = deque->leftindex;
-    size_t start_state = deque->state;
-    int cmp;
-
-    if (!_PyArg_ParseStack(args, nargs, "O|O&O&:index", &v,
-                           _PyEval_SliceIndexNotNone, &start,
-                           _PyEval_SliceIndexNotNone, &stop)) {
-        return NULL;
-    }
-
-    if (start < 0) {
-        start += Py_SIZE(deque);
-        if (start < 0)
-            start = 0;
-    }
-    if (stop < 0) {
-        stop += Py_SIZE(deque);
-        if (stop < 0)
-            stop = 0;
-    }
-    if (stop > Py_SIZE(deque))
-        stop = Py_SIZE(deque);
-    if (start > stop)
-        start = stop;
-    assert(0 <= start && start <= stop && stop <= Py_SIZE(deque));
-
-    /* XXX Replace this loop with faster code from deque_item() */
-    for (i=0 ; i<start ; i++) {
-        index++;
-        if (index == BLOCKLEN) {
-            b = b->rightlink;
-            index = 0;
-        }
-    }
-
-    n = stop - i;
-    while (--n >= 0) {
-        CHECK_NOT_END(b);
-        item = b->data[index];
-        cmp = PyObject_RichCompareBool(item, v, Py_EQ);
-        if (cmp > 0)
-            return PyLong_FromSsize_t(stop - n - 1);
-        if (cmp < 0)
-            return NULL;
-        if (start_state != deque->state) {
-            PyErr_SetString(PyExc_RuntimeError,
-                            "deque mutated during iteration");
-            return NULL;
-        }
-        index++;
-        if (index == BLOCKLEN) {
-            b = b->rightlink;
-            index = 0;
-        }
-    }
-    PyErr_Format(PyExc_ValueError, "%R is not in deque", v);
-    return NULL;
-}
-
-PyDoc_STRVAR(index_doc,
-"D.index(value, [start, [stop]]) -> integer -- return first index of value.\n"
-"Raises ValueError if the value is not present.");
-
-/* insert(), remove(), and delitem() are implemented in terms of
-   rotate() for simplicity and reasonable performance near the end
-   points.  If for some reason these methods become popular, it is not
-   hard to re-implement this using direct data movement (similar to
-   the code used in list slice assignments) and achieve a performance
-   boost (by moving each pointer only once instead of twice).
-*/
-
-static PyObject *
-deque_insert(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs)
-{
-    Py_ssize_t index;
-    Py_ssize_t n = Py_SIZE(deque);
-    PyObject *value;
-    PyObject *rv;
-
-    if (!_PyArg_ParseStack(args, nargs, "nO:insert", &index, &value)) {
-        return NULL;
-    }
-
-    if (deque->maxlen == Py_SIZE(deque)) {
-        PyErr_SetString(PyExc_IndexError, "deque already at its maximum size");
-        return NULL;
-    }
-    if (index >= n)
-        return deque_append(deque, value);
-    if (index <= -n || index == 0)
-        return deque_appendleft(deque, value);
-    if (_deque_rotate(deque, -index))
-        return NULL;
-    if (index < 0)
-        rv = deque_append(deque, value);
-    else
-        rv = deque_appendleft(deque, value);
-    if (rv == NULL)
-        return NULL;
-    Py_DECREF(rv);
-    if (_deque_rotate(deque, index))
-        return NULL;
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(insert_doc,
-"D.insert(index, object) -- insert object before index");
-
-static PyObject *
-deque_remove(dequeobject *deque, PyObject *value)
-{
-    Py_ssize_t i, n=Py_SIZE(deque);
-
-    for (i=0 ; i<n ; i++) {
-        PyObject *item = deque->leftblock->data[deque->leftindex];
-        int cmp = PyObject_RichCompareBool(item, value, Py_EQ);
-
-        if (Py_SIZE(deque) != n) {
-            PyErr_SetString(PyExc_IndexError,
-                "deque mutated during remove().");
-            return NULL;
-        }
-        if (cmp > 0) {
-            PyObject *tgt = deque_popleft(deque, NULL);
-            assert (tgt != NULL);
-            if (_deque_rotate(deque, i))
-                return NULL;
-            Py_DECREF(tgt);
-            Py_RETURN_NONE;
-        }
-        else if (cmp < 0) {
-            _deque_rotate(deque, i);
-            return NULL;
-        }
-        _deque_rotate(deque, -1);
-    }
-    PyErr_SetString(PyExc_ValueError, "deque.remove(x): x not in deque");
-    return NULL;
-}
-
-PyDoc_STRVAR(remove_doc,
-"D.remove(value) -- remove first occurrence of value.");
-
-static int
-valid_index(Py_ssize_t i, Py_ssize_t limit)
-{
-    /* The cast to size_t lets us use just a single comparison
-       to check whether i is in the range: 0 <= i < limit */
-    return (size_t) i < (size_t) limit;
-}
-
-static PyObject *
-deque_item(dequeobject *deque, Py_ssize_t i)
-{
-    block *b;
-    PyObject *item;
-    Py_ssize_t n, index=i;
-
-    if (!valid_index(i, Py_SIZE(deque))) {
-        PyErr_SetString(PyExc_IndexError, "deque index out of range");
-        return NULL;
-    }
-
-    if (i == 0) {
-        i = deque->leftindex;
-        b = deque->leftblock;
-    } else if (i == Py_SIZE(deque) - 1) {
-        i = deque->rightindex;
-        b = deque->rightblock;
-    } else {
-        i += deque->leftindex;
-        n = (Py_ssize_t)((size_t) i / BLOCKLEN);
-        i = (Py_ssize_t)((size_t) i % BLOCKLEN);
-        if (index < (Py_SIZE(deque) >> 1)) {
-            b = deque->leftblock;
-            while (--n >= 0)
-                b = b->rightlink;
-        } else {
-            n = (Py_ssize_t)(
-                    ((size_t)(deque->leftindex + Py_SIZE(deque) - 1))
-                    / BLOCKLEN - n);
-            b = deque->rightblock;
-            while (--n >= 0)
-                b = b->leftlink;
-        }
-    }
-    item = b->data[i];
-    Py_INCREF(item);
-    return item;
-}
-
-static int
-deque_del_item(dequeobject *deque, Py_ssize_t i)
-{
-    PyObject *item;
-    int rv;
-
-    assert (i >= 0 && i < Py_SIZE(deque));
-    if (_deque_rotate(deque, -i))
-        return -1;
-    item = deque_popleft(deque, NULL);
-    rv = _deque_rotate(deque, i);
-    assert (item != NULL);
-    Py_DECREF(item);
-    return rv;
-}
-
-static int
-deque_ass_item(dequeobject *deque, Py_ssize_t i, PyObject *v)
-{
-    PyObject *old_value;
-    block *b;
-    Py_ssize_t n, len=Py_SIZE(deque), halflen=(len+1)>>1, index=i;
-
-    if (!valid_index(i, len)) {
-        PyErr_SetString(PyExc_IndexError, "deque index out of range");
-        return -1;
-    }
-    if (v == NULL)
-        return deque_del_item(deque, i);
-
-    i += deque->leftindex;
-    n = (Py_ssize_t)((size_t) i / BLOCKLEN);
-    i = (Py_ssize_t)((size_t) i % BLOCKLEN);
-    if (index <= halflen) {
-        b = deque->leftblock;
-        while (--n >= 0)
-            b = b->rightlink;
-    } else {
-        n = (Py_ssize_t)(
-                ((size_t)(deque->leftindex + Py_SIZE(deque) - 1))
-                / BLOCKLEN - n);
-        b = deque->rightblock;
-        while (--n >= 0)
-            b = b->leftlink;
-    }
-    Py_INCREF(v);
-    old_value = b->data[i];
-    b->data[i] = v;
-    Py_DECREF(old_value);
-    return 0;
-}
-
-static void
-deque_dealloc(dequeobject *deque)
-{
-    PyObject_GC_UnTrack(deque);
-    if (deque->weakreflist != NULL)
-        PyObject_ClearWeakRefs((PyObject *) deque);
-    if (deque->leftblock != NULL) {
-        deque_clear(deque);
-        assert(deque->leftblock != NULL);
-        freeblock(deque->leftblock);
-    }
-    deque->leftblock = NULL;
-    deque->rightblock = NULL;
-    Py_TYPE(deque)->tp_free(deque);
-}
-
-static int
-deque_traverse(dequeobject *deque, visitproc visit, void *arg)
-{
-    block *b;
-    PyObject *item;
-    Py_ssize_t index;
-    Py_ssize_t indexlo = deque->leftindex;
-    Py_ssize_t indexhigh;
-
-    for (b = deque->leftblock; b != deque->rightblock; b = b->rightlink) {
-        for (index = indexlo; index < BLOCKLEN ; index++) {
-            item = b->data[index];
-            Py_VISIT(item);
-        }
-        indexlo = 0;
-    }
-    indexhigh = deque->rightindex;
-    for (index = indexlo; index <= indexhigh; index++) {
-        item = b->data[index];
-        Py_VISIT(item);
-    }
-    return 0;
-}
-
-static PyObject *
-deque_reduce(dequeobject *deque, PyObject *Py_UNUSED(ignored))
-{
-    PyObject *dict, *it;
-    _Py_IDENTIFIER(__dict__);
-
-    if (_PyObject_LookupAttrId((PyObject *)deque, &PyId___dict__, &dict) < 0) {
-        return NULL;
-    }
-    if (dict == NULL) {
-        dict = Py_None;
-        Py_INCREF(dict);
-    }
-
-    it = PyObject_GetIter((PyObject *)deque);
-    if (it == NULL) {
-        Py_DECREF(dict);
-        return NULL;
-    }
-
-    if (deque->maxlen < 0) {
-        return Py_BuildValue("O()NN", Py_TYPE(deque), dict, it);
-    }
-    else {
-        return Py_BuildValue("O(()n)NN", Py_TYPE(deque), deque->maxlen, dict, it);
-    }
-}
-
-PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
-
-static PyObject *
-deque_repr(PyObject *deque)
-{
-    PyObject *aslist, *result;
-    int i;
-
-    i = Py_ReprEnter(deque);
-    if (i != 0) {
-        if (i < 0)
-            return NULL;
-        return PyUnicode_FromString("[...]");
-    }
-
-    aslist = PySequence_List(deque);
-    if (aslist == NULL) {
-        Py_ReprLeave(deque);
-        return NULL;
-    }
-    if (((dequeobject *)deque)->maxlen >= 0)
-        result = PyUnicode_FromFormat("%s(%R, maxlen=%zd)",
-                                      _PyType_Name(Py_TYPE(deque)), aslist,
-                                      ((dequeobject *)deque)->maxlen);
-    else
-        result = PyUnicode_FromFormat("%s(%R)",
-                                      _PyType_Name(Py_TYPE(deque)), aslist);
-    Py_ReprLeave(deque);
-    Py_DECREF(aslist);
-    return result;
-}
-
-static PyObject *
-deque_richcompare(PyObject *v, PyObject *w, int op)
-{
-    PyObject *it1=NULL, *it2=NULL, *x, *y;
-    Py_ssize_t vs, ws;
-    int b, cmp=-1;
-
-    if (!PyObject_TypeCheck(v, &deque_type) ||
-        !PyObject_TypeCheck(w, &deque_type)) {
-        Py_RETURN_NOTIMPLEMENTED;
-    }
-
-    /* Shortcuts */
-    vs = Py_SIZE((dequeobject *)v);
-    ws = Py_SIZE((dequeobject *)w);
-    if (op == Py_EQ) {
-        if (v == w)
-            Py_RETURN_TRUE;
-        if (vs != ws)
-            Py_RETURN_FALSE;
-    }
-    if (op == Py_NE) {
-        if (v == w)
-            Py_RETURN_FALSE;
-        if (vs != ws)
-            Py_RETURN_TRUE;
-    }
-
-    /* Search for the first index where items are different */
-    it1 = PyObject_GetIter(v);
-    if (it1 == NULL)
-        goto done;
-    it2 = PyObject_GetIter(w);
-    if (it2 == NULL)
-        goto done;
-    for (;;) {
-        x = PyIter_Next(it1);
-        if (x == NULL && PyErr_Occurred())
-            goto done;
-        y = PyIter_Next(it2);
-        if (x == NULL || y == NULL)
-            break;
-        b = PyObject_RichCompareBool(x, y, Py_EQ);
-        if (b == 0) {
-            cmp = PyObject_RichCompareBool(x, y, op);
-            Py_DECREF(x);
-            Py_DECREF(y);
-            goto done;
-        }
-        Py_DECREF(x);
-        Py_DECREF(y);
-        if (b < 0)
-            goto done;
-    }
-    /* We reached the end of one deque or both */
-    Py_XDECREF(x);
-    Py_XDECREF(y);
-    if (PyErr_Occurred())
-        goto done;
-    switch (op) {
-    case Py_LT: cmp = y != NULL; break;  /* if w was longer */
-    case Py_LE: cmp = x == NULL; break;  /* if v was not longer */
-    case Py_EQ: cmp = x == y;    break;  /* if we reached the end of both */
-    case Py_NE: cmp = x != y;    break;  /* if one deque continues */
-    case Py_GT: cmp = x != NULL; break;  /* if v was longer */
-    case Py_GE: cmp = y == NULL; break;  /* if w was not longer */
-    }
-
-done:
-    Py_XDECREF(it1);
-    Py_XDECREF(it2);
-    if (cmp == 1)
-        Py_RETURN_TRUE;
-    if (cmp == 0)
-        Py_RETURN_FALSE;
-    return NULL;
-}
-
-static int
-deque_init(dequeobject *deque, PyObject *args, PyObject *kwdargs)
-{
-    PyObject *iterable = NULL;
-    PyObject *maxlenobj = NULL;
-    Py_ssize_t maxlen = -1;
-    char *kwlist[] = {"iterable", "maxlen", 0};
-
-    if (kwdargs == NULL) {
-        if (!PyArg_UnpackTuple(args, "deque()", 0, 2, &iterable, &maxlenobj))
-            return -1;
-    } else {
-        if (!PyArg_ParseTupleAndKeywords(args, kwdargs, "|OO:deque", kwlist,
-                                         &iterable, &maxlenobj))
-            return -1;
-    }
-    if (maxlenobj != NULL && maxlenobj != Py_None) {
-        maxlen = PyLong_AsSsize_t(maxlenobj);
-        if (maxlen == -1 && PyErr_Occurred())
-            return -1;
-        if (maxlen < 0) {
-            PyErr_SetString(PyExc_ValueError, "maxlen must be non-negative");
-            return -1;
-        }
-    }
-    deque->maxlen = maxlen;
-    if (Py_SIZE(deque) > 0)
-        deque_clear(deque);
-    if (iterable != NULL) {
-        PyObject *rv = deque_extend(deque, iterable);
-        if (rv == NULL)
-            return -1;
-        Py_DECREF(rv);
-    }
-    return 0;
-}
-
-static PyObject *
-deque_sizeof(dequeobject *deque, void *unused)
-{
-    Py_ssize_t res;
-    Py_ssize_t blocks;
-
-    res = _PyObject_SIZE(Py_TYPE(deque));
-    blocks = (size_t)(deque->leftindex + Py_SIZE(deque) + BLOCKLEN - 1) / BLOCKLEN;
-    assert(deque->leftindex + Py_SIZE(deque) - 1 ==
-           (blocks - 1) * BLOCKLEN + deque->rightindex);
-    res += blocks * sizeof(block);
-    return PyLong_FromSsize_t(res);
-}
-
-PyDoc_STRVAR(sizeof_doc,
-"D.__sizeof__() -- size of D in memory, in bytes");
-
-static int
-deque_bool(dequeobject *deque)
-{
-    return Py_SIZE(deque) != 0;
-}
-
-static PyObject *
-deque_get_maxlen(dequeobject *deque, void *Py_UNUSED(ignored))
-{
-    if (deque->maxlen < 0)
-        Py_RETURN_NONE;
-    return PyLong_FromSsize_t(deque->maxlen);
-}
-
-
-/* deque object ********************************************************/
-
-static PyGetSetDef deque_getset[] = {
-    {"maxlen", (getter)deque_get_maxlen, (setter)NULL,
-     "maximum size of a deque or None if unbounded"},
-    {0}
-};
-
-static PySequenceMethods deque_as_sequence = {
-    (lenfunc)deque_len,                 /* sq_length */
-    (binaryfunc)deque_concat,           /* sq_concat */
-    (ssizeargfunc)deque_repeat,         /* sq_repeat */
-    (ssizeargfunc)deque_item,           /* sq_item */
-    0,                                  /* sq_slice */
-    (ssizeobjargproc)deque_ass_item,    /* sq_ass_item */
-    0,                                  /* sq_ass_slice */
-    (objobjproc)deque_contains,         /* sq_contains */
-    (binaryfunc)deque_inplace_concat,   /* sq_inplace_concat */
-    (ssizeargfunc)deque_inplace_repeat, /* sq_inplace_repeat */
-};
-
-static PyNumberMethods deque_as_number = {
-    0,                                  /* nb_add */
-    0,                                  /* nb_subtract */
-    0,                                  /* nb_multiply */
-    0,                                  /* nb_remainder */
-    0,                                  /* nb_divmod */
-    0,                                  /* nb_power */
-    0,                                  /* nb_negative */
-    0,                                  /* nb_positive */
-    0,                                  /* nb_absolute */
-    (inquiry)deque_bool,                /* nb_bool */
-    0,                                  /* nb_invert */
- };
-
-static PyObject *deque_iter(dequeobject *deque);
-static PyObject *deque_reviter(dequeobject *deque);
-PyDoc_STRVAR(reversed_doc,
-    "D.__reversed__() -- return a reverse iterator over the deque");
-
-static PyMethodDef deque_methods[] = {
-    {"append",                  (PyCFunction)deque_append,
-        METH_O,                  append_doc},
-    {"appendleft",              (PyCFunction)deque_appendleft,
-        METH_O,                  appendleft_doc},
-    {"clear",                   (PyCFunction)deque_clearmethod,
-        METH_NOARGS,             clear_doc},
-    {"__copy__",                (PyCFunction)deque_copy,
-        METH_NOARGS,             copy_doc},
-    {"copy",                    (PyCFunction)deque_copy,
-        METH_NOARGS,             copy_doc},
-    {"count",                   (PyCFunction)deque_count,
-        METH_O,                  count_doc},
-    {"extend",                  (PyCFunction)deque_extend,
-        METH_O,                  extend_doc},
-    {"extendleft",              (PyCFunction)deque_extendleft,
-        METH_O,                  extendleft_doc},
-    {"index",                   (PyCFunction)deque_index,
-        METH_FASTCALL,            index_doc},
-    {"insert",                  (PyCFunction)deque_insert,
-        METH_FASTCALL,            insert_doc},
-    {"pop",                     (PyCFunction)deque_pop,
-        METH_NOARGS,             pop_doc},
-    {"popleft",                 (PyCFunction)deque_popleft,
-        METH_NOARGS,             popleft_doc},
-    {"__reduce__",              (PyCFunction)deque_reduce,
-        METH_NOARGS,             reduce_doc},
-    {"remove",                  (PyCFunction)deque_remove,
-        METH_O,                  remove_doc},
-    {"__reversed__",            (PyCFunction)deque_reviter,
-        METH_NOARGS,             reversed_doc},
-    {"reverse",                 (PyCFunction)deque_reverse,
-        METH_NOARGS,             reverse_doc},
-    {"rotate",                  (PyCFunction)deque_rotate,
-        METH_FASTCALL,            rotate_doc},
-    {"__sizeof__",              (PyCFunction)deque_sizeof,
-        METH_NOARGS,             sizeof_doc},
-    {NULL,              NULL}   /* sentinel */
-};
-
-PyDoc_STRVAR(deque_doc,
-"deque([iterable[, maxlen]]) --> deque object\n\
-\n\
-A list-like sequence optimized for data accesses near its endpoints.");
-
-static PyTypeObject deque_type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "collections.deque",                /* tp_name */
-    sizeof(dequeobject),                /* tp_basicsize */
-    0,                                  /* tp_itemsize */
-    /* methods */
-    (destructor)deque_dealloc,          /* tp_dealloc */
-    0,                                  /* tp_print */
-    0,                                  /* tp_getattr */
-    0,                                  /* tp_setattr */
-    0,                                  /* tp_reserved */
-    deque_repr,                         /* tp_repr */
-    &deque_as_number,                   /* tp_as_number */
-    &deque_as_sequence,                 /* tp_as_sequence */
-    0,                                  /* tp_as_mapping */
-    PyObject_HashNotImplemented,        /* tp_hash */
-    0,                                  /* tp_call */
-    0,                                  /* tp_str */
-    PyObject_GenericGetAttr,            /* tp_getattro */
-    0,                                  /* tp_setattro */
-    0,                                  /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
-                                        /* tp_flags */
-    deque_doc,                          /* tp_doc */
-    (traverseproc)deque_traverse,       /* tp_traverse */
-    (inquiry)deque_clear,               /* tp_clear */
-    (richcmpfunc)deque_richcompare,     /* tp_richcompare */
-    offsetof(dequeobject, weakreflist), /* tp_weaklistoffset*/
-    (getiterfunc)deque_iter,            /* tp_iter */
-    0,                                  /* tp_iternext */
-    deque_methods,                      /* tp_methods */
-    0,                                  /* tp_members */
-    deque_getset,                       /* tp_getset */
-    0,                                  /* tp_base */
-    0,                                  /* tp_dict */
-    0,                                  /* tp_descr_get */
-    0,                                  /* tp_descr_set */
-    0,                                  /* tp_dictoffset */
-    (initproc)deque_init,               /* tp_init */
-    PyType_GenericAlloc,                /* tp_alloc */
-    deque_new,                          /* tp_new */
-    PyObject_GC_Del,                    /* tp_free */
-};
-
-/*********************** Deque Iterator **************************/
-
-typedef struct {
-    PyObject_HEAD
-    block *b;
-    Py_ssize_t index;
-    dequeobject *deque;
-    size_t state;          /* state when the iterator is created */
-    Py_ssize_t counter;    /* number of items remaining for iteration */
-} dequeiterobject;
-
-static PyTypeObject dequeiter_type;
-
-static PyObject *
-deque_iter(dequeobject *deque)
-{
-    dequeiterobject *it;
-
-    it = PyObject_GC_New(dequeiterobject, &dequeiter_type);
-    if (it == NULL)
-        return NULL;
-    it->b = deque->leftblock;
-    it->index = deque->leftindex;
-    Py_INCREF(deque);
-    it->deque = deque;
-    it->state = deque->state;
-    it->counter = Py_SIZE(deque);
-    PyObject_GC_Track(it);
-    return (PyObject *)it;
-}
-
-static int
-dequeiter_traverse(dequeiterobject *dio, visitproc visit, void *arg)
-{
-    Py_VISIT(dio->deque);
-    return 0;
-}
-
-static void
-dequeiter_dealloc(dequeiterobject *dio)
-{
-    /* bpo-31095: UnTrack is needed before calling any callbacks */
-    PyObject_GC_UnTrack(dio);
-    Py_XDECREF(dio->deque);
-    PyObject_GC_Del(dio);
-}
-
-static PyObject *
-dequeiter_next(dequeiterobject *it)
-{
-    PyObject *item;
-
-    if (it->deque->state != it->state) {
-        it->counter = 0;
-        PyErr_SetString(PyExc_RuntimeError,
-                        "deque mutated during iteration");
-        return NULL;
-    }
-    if (it->counter == 0)
-        return NULL;
-    assert (!(it->b == it->deque->rightblock &&
-              it->index > it->deque->rightindex));
-
-    item = it->b->data[it->index];
-    it->index++;
-    it->counter--;
-    if (it->index == BLOCKLEN && it->counter > 0) {
-        CHECK_NOT_END(it->b->rightlink);
-        it->b = it->b->rightlink;
-        it->index = 0;
-    }
-    Py_INCREF(item);
-    return item;
-}
-
-static PyObject *
-dequeiter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    Py_ssize_t i, index=0;
-    PyObject *deque;
-    dequeiterobject *it;
-    if (!PyArg_ParseTuple(args, "O!|n", &deque_type, &deque, &index))
-        return NULL;
-    assert(type == &dequeiter_type);
-
-    it = (dequeiterobject*)deque_iter((dequeobject *)deque);
-    if (!it)
-        return NULL;
-    /* consume items from the queue */
-    for(i=0; i<index; i++) {
-        PyObject *item = dequeiter_next(it);
-        if (item) {
-            Py_DECREF(item);
-        } else {
-            if (it->counter) {
-                Py_DECREF(it);
-                return NULL;
-            } else
-                break;
-        }
-    }
-    return (PyObject*)it;
-}
-
-static PyObject *
-dequeiter_len(dequeiterobject *it)
-{
-    return PyLong_FromSsize_t(it->counter);
-}
-
-PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
-
-static PyObject *
-dequeiter_reduce(dequeiterobject *it)
-{
-    return Py_BuildValue("O(On)", Py_TYPE(it), it->deque, Py_SIZE(it->deque) - it->counter);
-}
-
-static PyMethodDef dequeiter_methods[] = {
-    {"__length_hint__", (PyCFunction)dequeiter_len, METH_NOARGS, length_hint_doc},
-    {"__reduce__", (PyCFunction)dequeiter_reduce, METH_NOARGS, reduce_doc},
-    {NULL,              NULL}           /* sentinel */
-};
-
-static PyTypeObject dequeiter_type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "_collections._deque_iterator",             /* tp_name */
-    sizeof(dequeiterobject),                    /* tp_basicsize */
-    0,                                          /* tp_itemsize */
-    /* methods */
-    (destructor)dequeiter_dealloc,              /* tp_dealloc */
-    0,                                          /* tp_print */
-    0,                                          /* tp_getattr */
-    0,                                          /* tp_setattr */
-    0,                                          /* tp_reserved */
-    0,                                          /* tp_repr */
-    0,                                          /* tp_as_number */
-    0,                                          /* tp_as_sequence */
-    0,                                          /* tp_as_mapping */
-    0,                                          /* tp_hash */
-    0,                                          /* tp_call */
-    0,                                          /* tp_str */
-    PyObject_GenericGetAttr,                    /* tp_getattro */
-    0,                                          /* tp_setattro */
-    0,                                          /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,    /* tp_flags */
-    0,                                          /* tp_doc */
-    (traverseproc)dequeiter_traverse,           /* tp_traverse */
-    0,                                          /* tp_clear */
-    0,                                          /* tp_richcompare */
-    0,                                          /* tp_weaklistoffset */
-    PyObject_SelfIter,                          /* tp_iter */
-    (iternextfunc)dequeiter_next,               /* tp_iternext */
-    dequeiter_methods,                          /* tp_methods */
-    0,                                          /* tp_members */
-    0,                                          /* tp_getset */
-    0,                                          /* tp_base */
-    0,                                          /* tp_dict */
-    0,                                          /* tp_descr_get */
-    0,                                          /* tp_descr_set */
-    0,                                          /* tp_dictoffset */
-    0,                                          /* tp_init */
-    0,                                          /* tp_alloc */
-    dequeiter_new,                              /* tp_new */
-    0,
-};
-
-/*********************** Deque Reverse Iterator **************************/
-
-static PyTypeObject dequereviter_type;
-
-static PyObject *
-deque_reviter(dequeobject *deque)
-{
-    dequeiterobject *it;
-
-    it = PyObject_GC_New(dequeiterobject, &dequereviter_type);
-    if (it == NULL)
-        return NULL;
-    it->b = deque->rightblock;
-    it->index = deque->rightindex;
-    Py_INCREF(deque);
-    it->deque = deque;
-    it->state = deque->state;
-    it->counter = Py_SIZE(deque);
-    PyObject_GC_Track(it);
-    return (PyObject *)it;
-}
-
-static PyObject *
-dequereviter_next(dequeiterobject *it)
-{
-    PyObject *item;
-    if (it->counter == 0)
-        return NULL;
-
-    if (it->deque->state != it->state) {
-        it->counter = 0;
-        PyErr_SetString(PyExc_RuntimeError,
-                        "deque mutated during iteration");
-        return NULL;
-    }
-    assert (!(it->b == it->deque->leftblock &&
-              it->index < it->deque->leftindex));
-
-    item = it->b->data[it->index];
-    it->index--;
-    it->counter--;
-    if (it->index < 0 && it->counter > 0) {
-        CHECK_NOT_END(it->b->leftlink);
-        it->b = it->b->leftlink;
-        it->index = BLOCKLEN - 1;
-    }
-    Py_INCREF(item);
-    return item;
-}
-
-static PyObject *
-dequereviter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    Py_ssize_t i, index=0;
-    PyObject *deque;
-    dequeiterobject *it;
-    if (!PyArg_ParseTuple(args, "O!|n", &deque_type, &deque, &index))
-        return NULL;
-    assert(type == &dequereviter_type);
-
-    it = (dequeiterobject*)deque_reviter((dequeobject *)deque);
-    if (!it)
-        return NULL;
-    /* consume items from the queue */
-    for(i=0; i<index; i++) {
-        PyObject *item = dequereviter_next(it);
-        if (item) {
-            Py_DECREF(item);
-        } else {
-            if (it->counter) {
-                Py_DECREF(it);
-                return NULL;
-            } else
-                break;
-        }
-    }
-    return (PyObject*)it;
-}
-
-static PyTypeObject dequereviter_type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "_collections._deque_reverse_iterator",     /* tp_name */
-    sizeof(dequeiterobject),                    /* tp_basicsize */
-    0,                                          /* tp_itemsize */
-    /* methods */
-    (destructor)dequeiter_dealloc,              /* tp_dealloc */
-    0,                                          /* tp_print */
-    0,                                          /* tp_getattr */
-    0,                                          /* tp_setattr */
-    0,                                          /* tp_reserved */
-    0,                                          /* tp_repr */
-    0,                                          /* tp_as_number */
-    0,                                          /* tp_as_sequence */
-    0,                                          /* tp_as_mapping */
-    0,                                          /* tp_hash */
-    0,                                          /* tp_call */
-    0,                                          /* tp_str */
-    PyObject_GenericGetAttr,                    /* tp_getattro */
-    0,                                          /* tp_setattro */
-    0,                                          /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,    /* tp_flags */
-    0,                                          /* tp_doc */
-    (traverseproc)dequeiter_traverse,           /* tp_traverse */
-    0,                                          /* tp_clear */
-    0,                                          /* tp_richcompare */
-    0,                                          /* tp_weaklistoffset */
-    PyObject_SelfIter,                          /* tp_iter */
-    (iternextfunc)dequereviter_next,            /* tp_iternext */
-    dequeiter_methods,                          /* tp_methods */
-    0,                                          /* tp_members */
-    0,                                          /* tp_getset */
-    0,                                          /* tp_base */
-    0,                                          /* tp_dict */
-    0,                                          /* tp_descr_get */
-    0,                                          /* tp_descr_set */
-    0,                                          /* tp_dictoffset */
-    0,                                          /* tp_init */
-    0,                                          /* tp_alloc */
-    dequereviter_new,                           /* tp_new */
-    0,
-};
-
-/* defaultdict type *********************************************************/
-
-typedef struct {
-    PyDictObject dict;
-    PyObject *default_factory;
-} defdictobject;
-
-static PyTypeObject defdict_type; /* Forward */
-
-PyDoc_STRVAR(defdict_missing_doc,
-"__missing__(key) # Called by __getitem__ for missing key; pseudo-code:\n\
-  if self.default_factory is None: raise KeyError((key,))\n\
-  self[key] = value = self.default_factory()\n\
-  return value\n\
-");
-
-static PyObject *
-defdict_missing(defdictobject *dd, PyObject *key)
-{
-    PyObject *factory = dd->default_factory;
-    PyObject *value;
-    if (factory == NULL || factory == Py_None) {
-        /* XXX Call dict.__missing__(key) */
-        PyObject *tup;
-        tup = PyTuple_Pack(1, key);
-        if (!tup) return NULL;
-        PyErr_SetObject(PyExc_KeyError, tup);
-        Py_DECREF(tup);
-        return NULL;
-    }
-    value = PyEval_CallObject(factory, NULL);
-    if (value == NULL)
-        return value;
-    if (PyObject_SetItem((PyObject *)dd, key, value) < 0) {
-        Py_DECREF(value);
-        return NULL;
-    }
-    return value;
-}
-
-PyDoc_STRVAR(defdict_copy_doc, "D.copy() -> a shallow copy of D.");
-
-static PyObject *
-defdict_copy(defdictobject *dd)
-{
-    /* This calls the object's class.  That only works for subclasses
-       whose class constructor has the same signature.  Subclasses that
-       define a different constructor signature must override copy().
-    */
-
-    if (dd->default_factory == NULL)
-        return PyObject_CallFunctionObjArgs((PyObject*)Py_TYPE(dd), Py_None, dd, NULL);
-    return PyObject_CallFunctionObjArgs((PyObject*)Py_TYPE(dd),
-                                        dd->default_factory, dd, NULL);
-}
-
-static PyObject *
-defdict_reduce(defdictobject *dd)
-{
-    /* __reduce__ must return a 5-tuple as follows:
-
-       - factory function
-       - tuple of args for the factory function
-       - additional state (here None)
-       - sequence iterator (here None)
-       - dictionary iterator (yielding successive (key, value) pairs
-
-       This API is used by pickle.py and copy.py.
-
-       For this to be useful with pickle.py, the default_factory
-       must be picklable; e.g., None, a built-in, or a global
-       function in a module or package.
-
-       Both shallow and deep copying are supported, but for deep
-       copying, the default_factory must be deep-copyable; e.g. None,
-       or a built-in (functions are not copyable at this time).
-
-       This only works for subclasses as long as their constructor
-       signature is compatible; the first argument must be the
-       optional default_factory, defaulting to None.
-    */
-    PyObject *args;
-    PyObject *items;
-    PyObject *iter;
-    PyObject *result;
-    _Py_IDENTIFIER(items);
-
-    if (dd->default_factory == NULL || dd->default_factory == Py_None)
-        args = PyTuple_New(0);
-    else
-        args = PyTuple_Pack(1, dd->default_factory);
-    if (args == NULL)
-        return NULL;
-    items = _PyObject_CallMethodId((PyObject *)dd, &PyId_items, NULL);
-    if (items == NULL) {
-        Py_DECREF(args);
-        return NULL;
-    }
-    iter = PyObject_GetIter(items);
-    if (iter == NULL) {
-        Py_DECREF(items);
-        Py_DECREF(args);
-        return NULL;
-    }
-    result = PyTuple_Pack(5, Py_TYPE(dd), args,
-                          Py_None, Py_None, iter);
-    Py_DECREF(iter);
-    Py_DECREF(items);
-    Py_DECREF(args);
-    return result;
-}
-
-static PyMethodDef defdict_methods[] = {
-    {"__missing__", (PyCFunction)defdict_missing, METH_O,
-     defdict_missing_doc},
-    {"copy", (PyCFunction)defdict_copy, METH_NOARGS,
-     defdict_copy_doc},
-    {"__copy__", (PyCFunction)defdict_copy, METH_NOARGS,
-     defdict_copy_doc},
-    {"__reduce__", (PyCFunction)defdict_reduce, METH_NOARGS,
-     reduce_doc},
-    {NULL}
-};
-
-static PyMemberDef defdict_members[] = {
-    {"default_factory", T_OBJECT,
-     offsetof(defdictobject, default_factory), 0,
-     PyDoc_STR("Factory for default value called by __missing__().")},
-    {NULL}
-};
-
-static void
-defdict_dealloc(defdictobject *dd)
-{
-    /* bpo-31095: UnTrack is needed before calling any callbacks */
-    PyObject_GC_UnTrack(dd);
-    Py_CLEAR(dd->default_factory);
-    PyDict_Type.tp_dealloc((PyObject *)dd);
-}
-
-static PyObject *
-defdict_repr(defdictobject *dd)
-{
-    PyObject *baserepr;
-    PyObject *defrepr;
-    PyObject *result;
-    baserepr = PyDict_Type.tp_repr((PyObject *)dd);
-    if (baserepr == NULL)
-        return NULL;
-    if (dd->default_factory == NULL)
-        defrepr = PyUnicode_FromString("None");
-    else
-    {
-        int status = Py_ReprEnter(dd->default_factory);
-        if (status != 0) {
-            if (status < 0) {
-                Py_DECREF(baserepr);
-                return NULL;
-            }
-            defrepr = PyUnicode_FromString("...");
-        }
-        else
-            defrepr = PyObject_Repr(dd->default_factory);
-        Py_ReprLeave(dd->default_factory);
-    }
-    if (defrepr == NULL) {
-        Py_DECREF(baserepr);
-        return NULL;
-    }
-    result = PyUnicode_FromFormat("%s(%U, %U)",
-                                  _PyType_Name(Py_TYPE(dd)),
-                                  defrepr, baserepr);
-    Py_DECREF(defrepr);
-    Py_DECREF(baserepr);
-    return result;
-}
-
-static int
-defdict_traverse(PyObject *self, visitproc visit, void *arg)
-{
-    Py_VISIT(((defdictobject *)self)->default_factory);
-    return PyDict_Type.tp_traverse(self, visit, arg);
-}
-
-static int
-defdict_tp_clear(defdictobject *dd)
-{
-    Py_CLEAR(dd->default_factory);
-    return PyDict_Type.tp_clear((PyObject *)dd);
-}
-
-static int
-defdict_init(PyObject *self, PyObject *args, PyObject *kwds)
-{
-    defdictobject *dd = (defdictobject *)self;
-    PyObject *olddefault = dd->default_factory;
-    PyObject *newdefault = NULL;
-    PyObject *newargs;
-    int result;
-    if (args == NULL || !PyTuple_Check(args))
-        newargs = PyTuple_New(0);
-    else {
-        Py_ssize_t n = PyTuple_GET_SIZE(args);
-        if (n > 0) {
-            newdefault = PyTuple_GET_ITEM(args, 0);
-            if (!PyCallable_Check(newdefault) && newdefault != Py_None) {
-                PyErr_SetString(PyExc_TypeError,
-                    "first argument must be callable or None");
-                return -1;
-            }
-        }
-        newargs = PySequence_GetSlice(args, 1, n);
-    }
-    if (newargs == NULL)
-        return -1;
-    Py_XINCREF(newdefault);
-    dd->default_factory = newdefault;
-    result = PyDict_Type.tp_init(self, newargs, kwds);
-    Py_DECREF(newargs);
-    Py_XDECREF(olddefault);
-    return result;
-}
-
-PyDoc_STRVAR(defdict_doc,
-"defaultdict(default_factory[, ...]) --> dict with default factory\n\
-\n\
-The default factory is called without arguments to produce\n\
-a new value when a key is not present, in __getitem__ only.\n\
-A defaultdict compares equal to a dict with the same items.\n\
-All remaining arguments are treated the same as if they were\n\
-passed to the dict constructor, including keyword arguments.\n\
-");
-
-/* See comment in xxsubtype.c */
-#define DEFERRED_ADDRESS(ADDR) 0
-
-static PyTypeObject defdict_type = {
-    PyVarObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type), 0)
-    "collections.defaultdict",          /* tp_name */
-    sizeof(defdictobject),              /* tp_basicsize */
-    0,                                  /* tp_itemsize */
-    /* methods */
-    (destructor)defdict_dealloc,        /* tp_dealloc */
-    0,                                  /* tp_print */
-    0,                                  /* tp_getattr */
-    0,                                  /* tp_setattr */
-    0,                                  /* tp_reserved */
-    (reprfunc)defdict_repr,             /* tp_repr */
-    0,                                  /* tp_as_number */
-    0,                                  /* tp_as_sequence */
-    0,                                  /* tp_as_mapping */
-    0,                                  /* tp_hash */
-    0,                                  /* tp_call */
-    0,                                  /* tp_str */
-    PyObject_GenericGetAttr,            /* tp_getattro */
-    0,                                  /* tp_setattro */
-    0,                                  /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
-                                    /* tp_flags */
-    defdict_doc,                        /* tp_doc */
-    defdict_traverse,                   /* tp_traverse */
-    (inquiry)defdict_tp_clear,          /* tp_clear */
-    0,                                  /* tp_richcompare */
-    0,                                  /* tp_weaklistoffset*/
-    0,                                  /* tp_iter */
-    0,                                  /* tp_iternext */
-    defdict_methods,                    /* tp_methods */
-    defdict_members,                    /* tp_members */
-    0,                                  /* tp_getset */
-    DEFERRED_ADDRESS(&PyDict_Type),     /* tp_base */
-    0,                                  /* tp_dict */
-    0,                                  /* tp_descr_get */
-    0,                                  /* tp_descr_set */
-    0,                                  /* tp_dictoffset */
-    defdict_init,                       /* tp_init */
-    PyType_GenericAlloc,                /* tp_alloc */
-    0,                                  /* tp_new */
-    PyObject_GC_Del,                    /* tp_free */
-};
-
-/* helper function for Counter  *********************************************/
-
-PyDoc_STRVAR(_count_elements_doc,
-"_count_elements(mapping, iterable) -> None\n\
-\n\
-Count elements in the iterable, updating the mapping");
-
-static PyObject *
-_count_elements(PyObject *self, PyObject *args)
-{
-    _Py_IDENTIFIER(get);
-    _Py_IDENTIFIER(__setitem__);
-    PyObject *it, *iterable, *mapping, *oldval;
-    PyObject *newval = NULL;
-    PyObject *key = NULL;
-    PyObject *bound_get = NULL;
-    PyObject *mapping_get;
-    PyObject *dict_get;
-    PyObject *mapping_setitem;
-    PyObject *dict_setitem;
-
-    if (!PyArg_UnpackTuple(args, "_count_elements", 2, 2, &mapping, &iterable))
-        return NULL;
-
-    it = PyObject_GetIter(iterable);
-    if (it == NULL)
-        return NULL;
-
-    /* Only take the fast path when get() and __setitem__()
-     * have not been overridden.
-     */
-    mapping_get = _PyType_LookupId(Py_TYPE(mapping), &PyId_get);
-    dict_get = _PyType_LookupId(&PyDict_Type, &PyId_get);
-    mapping_setitem = _PyType_LookupId(Py_TYPE(mapping), &PyId___setitem__);
-    dict_setitem = _PyType_LookupId(&PyDict_Type, &PyId___setitem__);
-
-    if (mapping_get != NULL && mapping_get == dict_get &&
-        mapping_setitem != NULL && mapping_setitem == dict_setitem &&
-        PyDict_Check(mapping))
-    {
-        while (1) {
-            /* Fast path advantages:
-                   1. Eliminate double hashing
-                      (by re-using the same hash for both the get and set)
-                   2. Avoid argument overhead of PyObject_CallFunctionObjArgs
-                      (argument tuple creation and parsing)
-                   3. Avoid indirection through a bound method object
-                      (creates another argument tuple)
-                   4. Avoid initial increment from zero
-                      (reuse an existing one-object instead)
-            */
-            Py_hash_t hash;
-
-            key = PyIter_Next(it);
-            if (key == NULL)
-                break;
-
-            if (!PyUnicode_CheckExact(key) ||
-                (hash = ((PyASCIIObject *) key)->hash) == -1)
-            {
-                hash = PyObject_Hash(key);
-                if (hash == -1)
-                    goto done;
-            }
-
-            oldval = _PyDict_GetItem_KnownHash(mapping, key, hash);
-            if (oldval == NULL) {
-                if (PyErr_Occurred())
-                    goto done;
-                if (_PyDict_SetItem_KnownHash(mapping, key, _PyLong_One, hash) < 0)
-                    goto done;
-            } else {
-                newval = PyNumber_Add(oldval, _PyLong_One);
-                if (newval == NULL)
-                    goto done;
-                if (_PyDict_SetItem_KnownHash(mapping, key, newval, hash) < 0)
-                    goto done;
-                Py_CLEAR(newval);
-            }
-            Py_DECREF(key);
-        }
-    } else {
-        bound_get = _PyObject_GetAttrId(mapping, &PyId_get);
-        if (bound_get == NULL)
-            goto done;
-
-        while (1) {
-            key = PyIter_Next(it);
-            if (key == NULL)
-                break;
-            oldval = PyObject_CallFunctionObjArgs(bound_get, key, _PyLong_Zero, NULL);
-            if (oldval == NULL)
-                break;
-            newval = PyNumber_Add(oldval, _PyLong_One);
-            Py_DECREF(oldval);
-            if (newval == NULL)
-                break;
-            if (PyObject_SetItem(mapping, key, newval) < 0)
-                break;
-            Py_CLEAR(newval);
-            Py_DECREF(key);
-        }
-    }
-
-done:
-    Py_DECREF(it);
-    Py_XDECREF(key);
-    Py_XDECREF(newval);
-    Py_XDECREF(bound_get);
-    if (PyErr_Occurred())
-        return NULL;
-    Py_RETURN_NONE;
-}
-
-/* module level code ********************************************************/
-
-PyDoc_STRVAR(module_doc,
-"High performance data structures.\n\
-- deque:        ordered collection accessible from endpoints only\n\
-- defaultdict:  dict subclass with a default value factory\n\
-");
-
-static struct PyMethodDef module_functions[] = {
-    {"_count_elements", _count_elements,    METH_VARARGS,   _count_elements_doc},
-    {NULL,       NULL}          /* sentinel */
-};
-
-static struct PyModuleDef _collectionsmodule = {
-    PyModuleDef_HEAD_INIT,
-    "_collections",
-    module_doc,
-    -1,
-    module_functions,
-    NULL,
-    NULL,
-    NULL,
-    NULL
-};
-
-PyMODINIT_FUNC
-PyInit__collections(void)
-{
-    PyObject *m;
-
-    m = PyModule_Create(&_collectionsmodule);
-    if (m == NULL)
-        return NULL;
-
-    if (PyType_Ready(&deque_type) < 0)
-        return NULL;
-    Py_INCREF(&deque_type);
-    PyModule_AddObject(m, "deque", (PyObject *)&deque_type);
-
-    defdict_type.tp_base = &PyDict_Type;
-    if (PyType_Ready(&defdict_type) < 0)
-        return NULL;
-    Py_INCREF(&defdict_type);
-    PyModule_AddObject(m, "defaultdict", (PyObject *)&defdict_type);
-
-    Py_INCREF(&PyODict_Type);
-    PyModule_AddObject(m, "OrderedDict", (PyObject *)&PyODict_Type);
-
-    if (PyType_Ready(&dequeiter_type) < 0)
-        return NULL;
-    Py_INCREF(&dequeiter_type);
-    PyModule_AddObject(m, "_deque_iterator", (PyObject *)&dequeiter_type);
-
-    if (PyType_Ready(&dequereviter_type) < 0)
-        return NULL;
-    Py_INCREF(&dequereviter_type);
-    PyModule_AddObject(m, "_deque_reverse_iterator", (PyObject *)&dequereviter_type);
-
-    return m;
-}
diff --git a/Modules/_ctypes/callbacks.c b/Modules/_ctypes/callbacks.c
index ec9f44336e0e196..5a8303fba290cbf 100644
--- a/Modules/_ctypes/callbacks.c
+++ b/Modules/_ctypes/callbacks.c
@@ -160,14 +160,14 @@ static void _CallPythonObject(void *mem,
         if (cnv)
             dict = PyType_stgdict(cnv);
         else {
-            PrintError("Getting argument converter %d\n", i);
+            PrintError("Getting argument converter %zd\n", i);
             goto Done;
         }
 
         if (dict && dict->getfunc && !_ctypes_simple_instance(cnv)) {
             PyObject *v = dict->getfunc(*pArgs, dict->size);
             if (!v) {
-                PrintError("create argument %d:\n", i);
+                PrintError("create argument %zd:\n", i);
                 Py_DECREF(cnv);
                 goto Done;
             }
@@ -181,14 +181,14 @@ static void _CallPythonObject(void *mem,
             /* Hm, shouldn't we use PyCData_AtAddress() or something like that instead? */
             CDataObject *obj = (CDataObject *)_PyObject_CallNoArg(cnv);
             if (!obj) {
-                PrintError("create argument %d:\n", i);
+                PrintError("create argument %zd:\n", i);
                 Py_DECREF(cnv);
                 goto Done;
             }
             if (!CDataObject_Check(obj)) {
                 Py_DECREF(obj);
                 Py_DECREF(cnv);
-                PrintError("unexpected result of create argument %d:\n", i);
+                PrintError("unexpected result of create argument %zd:\n", i);
                 goto Done;
             }
             memcpy(obj->b_ptr, *pArgs, dict->size);
@@ -199,7 +199,7 @@ static void _CallPythonObject(void *mem,
         } else {
             PyErr_SetString(PyExc_TypeError,
                             "cannot build parameter");
-            PrintError("Parsing argument %d\n", i);
+            PrintError("Parsing argument %zd\n", i);
             Py_DECREF(cnv);
             goto Done;
         }
diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c
index e971388f69b92fb..ec854c864cc20f3 100644
--- a/Modules/_ctypes/callproc.c
+++ b/Modules/_ctypes/callproc.c
@@ -1125,20 +1125,20 @@ PyObject *_ctypes_callproc(PPROC pProc,
             converter = PyTuple_GET_ITEM(argtypes, i);
             v = PyObject_CallFunctionObjArgs(converter, arg, NULL);
             if (v == NULL) {
-                _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
+                _ctypes_extend_error(PyExc_ArgError, "argument %zd: ", i+1);
                 goto cleanup;
             }
 
             err = ConvParam(v, i+1, pa);
             Py_DECREF(v);
             if (-1 == err) {
-                _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
+                _ctypes_extend_error(PyExc_ArgError, "argument %zd: ", i+1);
                 goto cleanup;
             }
         } else {
             err = ConvParam(arg, i+1, pa);
             if (-1 == err) {
-                _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
+                _ctypes_extend_error(PyExc_ArgError, "argument %zd: ", i+1);
                 goto cleanup; /* leaking ? */
             }
         }
diff --git a/Modules/_ctypes/malloc_closure.c b/Modules/_ctypes/malloc_closure.c
index 248c6a67022bae0..8ad76497c7b3f25 100644
--- a/Modules/_ctypes/malloc_closure.c
+++ b/Modules/_ctypes/malloc_closure.c
@@ -76,7 +76,7 @@ static void more_core(void)
 
 #ifdef MALLOC_CLOSURE_DEBUG
     printf("block at %p allocated (%d bytes), %d ITEMs\n",
-           item, count * sizeof(ITEM), count);
+           item, count * (int)sizeof(ITEM), count);
 #endif
     /* put them into the free list */
     for (i = 0; i < count; ++i) {
diff --git a/Modules/_io/winconsoleio.c b/Modules/_io/winconsoleio.c
index c11c1e09f4c3a13..bf5b10b494744d3 100644
--- a/Modules/_io/winconsoleio.c
+++ b/Modules/_io/winconsoleio.c
@@ -724,7 +724,7 @@ readinto(winconsoleio *self, char *buf, Py_ssize_t len)
 
     if (u8n) {
         PyErr_Format(PyExc_SystemError,
-            "Buffer had room for %d bytes but %d bytes required",
+            "Buffer had room for %zd bytes but %u bytes required",
             len, u8n);
         return -1;
     }
diff --git a/Modules/_localemodule.c b/Modules/_localemodule.c
index 8efda35dd4e52a8..f94689811850719 100644
--- a/Modules/_localemodule.c
+++ b/Modules/_localemodule.c
@@ -394,7 +394,7 @@ PyLocale_getdefaultlocale(PyObject* self)
     char encoding[100];
     char locale[100];
 
-    PyOS_snprintf(encoding, sizeof(encoding), "cp%d", GetACP());
+    PyOS_snprintf(encoding, sizeof(encoding), "cp%u", GetACP());
 
     if (GetLocaleInfo(LOCALE_USER_DEFAULT,
                       LOCALE_SISO639LANGNAME,
diff --git a/Modules/_lzmamodule.c b/Modules/_lzmamodule.c
index bb7a7ec50ce059b..f93c6c668e5d048 100644
--- a/Modules/_lzmamodule.c
+++ b/Modules/_lzmamodule.c
@@ -219,7 +219,7 @@ parse_filter_spec_lzma(PyObject *spec)
 
     if (lzma_lzma_preset(options, preset)) {
         PyMem_Free(options);
-        PyErr_Format(Error, "Invalid compression preset: %d", preset);
+        PyErr_Format(Error, "Invalid compression preset: %u", preset);
         return NULL;
     }
 
@@ -630,7 +630,7 @@ Compressor_init_alone(lzma_stream *lzs, uint32_t preset, PyObject *filterspecs)
         lzma_options_lzma options;
 
         if (lzma_lzma_preset(&options, preset)) {
-            PyErr_Format(Error, "Invalid compression preset: %d", preset);
+            PyErr_Format(Error, "Invalid compression preset: %u", preset);
             return -1;
         }
         lzret = lzma_alone_encoder(lzs, &options);
diff --git a/Modules/_multiprocessing/semaphore.c b/Modules/_multiprocessing/semaphore.c
index 0cc46b53222ef9b..0f3e33d91e9d351 100644
--- a/Modules/_multiprocessing/semaphore.c
+++ b/Modules/_multiprocessing/semaphore.c
@@ -141,7 +141,7 @@ semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
     default:
         PyErr_Format(PyExc_RuntimeError, "WaitForSingleObject() or "
                      "WaitForMultipleObjects() gave unrecognized "
-                     "value %d", res);
+                     "value %u", res);
         return NULL;
     }
 }
diff --git a/Modules/_ssl.c b/Modules/_ssl.c
index 9baec8a9bc84e51..7076fddf8dd4d4d 100644
--- a/Modules/_ssl.c
+++ b/Modules/_ssl.c
@@ -3348,7 +3348,7 @@ _ssl__SSLContext__set_alpn_protocols_impl(PySSLContext *self,
 #if HAVE_ALPN
     if ((size_t)protos->len > UINT_MAX) {
         PyErr_Format(PyExc_OverflowError,
-            "protocols longer than %d bytes", UINT_MAX);
+            "protocols longer than %u bytes", UINT_MAX);
         return NULL;
     }
 
diff --git a/Modules/binascii.c b/Modules/binascii.c
index d0d3f7d34b8f6a2..c13bed6bbfdcaeb 100644
--- a/Modules/binascii.c
+++ b/Modules/binascii.c
@@ -520,7 +520,7 @@ binascii_a2b_base64_impl(PyObject *module, Py_buffer *data)
             */
             PyErr_Format(Error,
                          "Invalid base64-encoded string: "
-                         "number of data characters (%d) cannot be 1 more "
+                         "number of data characters (%zd) cannot be 1 more "
                          "than a multiple of 4",
                          (bin_data - bin_data_start) / 3 * 4 + 1);
         } else {
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index 988471e15fbe302..65385e8974cf9cd 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -4102,7 +4102,7 @@ sock_sendto(PySocketSockObject *s, PyObject *args)
             break;
         default:
             PyErr_Format(PyExc_TypeError,
-                         "sendto() takes 2 or 3 arguments (%d given)",
+                         "sendto() takes 2 or 3 arguments (%zd given)",
                          arglen);
             return NULL;
     }
@@ -4642,7 +4642,7 @@ sock_ioctl(PySocketSockObject *s, PyObject *arg)
         return PyLong_FromUnsignedLong(recv); }
 #endif
     default:
-        PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd);
+        PyErr_Format(PyExc_ValueError, "invalid ioctl command %lu", cmd);
         return NULL;
     }
 }
diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c
index 172c7f38b9e258a..a5319da48daab35 100644
--- a/Objects/bytesobject.c
+++ b/Objects/bytesobject.c
@@ -1209,7 +1209,7 @@ PyObject *_PyBytes_DecodeEscape(const char *s,
 
             if (!errors || strcmp(errors, "strict") == 0) {
                 PyErr_Format(PyExc_ValueError,
-                             "invalid \\x escape at position %d",
+                             "invalid \\x escape at position %zd",
                              s - 2 - (end - len));
                 goto failed;
             }
diff --git a/Objects/odictobject.c b/Objects/odictobject.c
index 7487bd96076420d..88afc61f6071da8 100644
--- a/Objects/odictobject.c
+++ b/Objects/odictobject.c
@@ -1538,7 +1538,7 @@ odict_init(PyObject *self, PyObject *args, PyObject *kwds)
     if (len == -1)
         return -1;
     if (len > 1) {
-        const char *msg = "expected at most 1 arguments, got %d";
+        const char *msg = "expected at most 1 arguments, got %zd";
         PyErr_Format(PyExc_TypeError, msg, len);
         return -1;
     }
@@ -2211,7 +2211,7 @@ mutablemapping_update(PyObject *self, PyObject *args, PyObject *kwargs)
     assert(args == NULL || PyTuple_Check(args));
     len = (args != NULL) ? PyTuple_GET_SIZE(args) : 0;
     if (len > 1) {
-        const char *msg = "update() takes at most 1 positional argument (%d given)";
+        const char *msg = "update() takes at most 1 positional argument (%zd given)";
         PyErr_Format(PyExc_TypeError, msg, len);
         return NULL;
     }
diff --git a/Objects/structseq.c b/Objects/structseq.c
index 1b71f724a66b096..900aaba7c150cb5 100644
--- a/Objects/structseq.c
+++ b/Objects/structseq.c
@@ -194,7 +194,7 @@ structseq_repr(PyStructSequence *obj)
 
         cname = typ->tp_members[i].name;
         if (cname == NULL) {
-            PyErr_Format(PyExc_SystemError, "In structseq_repr(), member %d name is NULL"
+            PyErr_Format(PyExc_SystemError, "In structseq_repr(), member %zd name is NULL"
                          " for type %.500s", i, typ->tp_name);
             return NULL;
         }
diff --git a/PC/launcher.c b/PC/launcher.c
index a4e678115f3470c..0f5003a8370e59b 100644
--- a/PC/launcher.c
+++ b/PC/launcher.c
@@ -718,7 +718,7 @@ invoke_child(wchar_t * executable, wchar_t * suffix, wchar_t * cmdline)
         }
         child_command = calloc(child_command_size, sizeof(wchar_t));
         if (child_command == NULL)
-            error(RC_CREATE_PROCESS, L"unable to allocate %d bytes for child command.",
+            error(RC_CREATE_PROCESS, L"unable to allocate %zd bytes for child command.",
                   child_command_size);
         if (no_suffix)
             _snwprintf_s(child_command, child_command_size,
@@ -1189,7 +1189,7 @@ maybe_handle_shebang(wchar_t ** argv, wchar_t * cmdline)
 
     if (rc == 0) {
         read = fread(buffer, sizeof(char), BUFSIZE, fp);
-        debug(L"maybe_handle_shebang: read %d bytes\n", read);
+        debug(L"maybe_handle_shebang: read %zd bytes\n", read);
         fclose(fp);
 
         if ((read >= 4) && (buffer[3] == '\n') && (buffer[2] == '\r')) {
@@ -1209,7 +1209,7 @@ maybe_handle_shebang(wchar_t ** argv, wchar_t * cmdline)
             bom = BOMs; /* points to UTF-8 entry - the default */
         }
         else {
-            debug(L"maybe_handle_shebang: BOM found, code page %d\n",
+            debug(L"maybe_handle_shebang: BOM found, code page %u\n",
                   bom->code_page);
             start = &buffer[bom->length];
         }
diff --git a/Python/dynload_win.c b/Python/dynload_win.c
index 0fdf77f55280ca4..51325be658af88a 100644
--- a/Python/dynload_win.c
+++ b/Python/dynload_win.c
@@ -254,7 +254,7 @@ dl_funcptr _PyImport_FindSharedFuncptrWindows(const char *prefix,
                This should not happen if called correctly. */
             if (theLength == 0) {
                 message = PyUnicode_FromFormat(
-                    "DLL load failed with error code %d",
+                    "DLL load failed with error code %u",
                     errorCode);
             } else {
                 /* For some reason a \r\n
diff --git a/Python/getargs.c b/Python/getargs.c
index 992cb216c257f97..73e47f84561b87e 100644
--- a/Python/getargs.c
+++ b/Python/getargs.c
@@ -371,14 +371,14 @@ vgetargs1_impl(PyObject *compat_args, PyObject *const *stack, Py_ssize_t nargs,
     if (nargs < min || max < nargs) {
         if (message == NULL)
             PyErr_Format(PyExc_TypeError,
-                         "%.150s%s takes %s %d argument%s (%ld given)",
+                         "%.150s%s takes %s %d argument%s (%zd given)",
                          fname==NULL ? "function" : fname,
                          fname==NULL ? "" : "()",
                          min==max ? "exactly"
                          : nargs < min ? "at least" : "at most",
                          nargs < min ? min : max,
                          (nargs < min ? min : max) == 1 ? "" : "s",
-                         Py_SAFE_DOWNCAST(nargs, Py_ssize_t, long));
+                         nargs);
         else
             PyErr_SetString(PyExc_TypeError, message);
         return cleanreturn(0, &freelist);
@@ -1718,7 +1718,7 @@ vgetargskeywords(PyObject *args, PyObject *kwargs, const char *format,
                 else {
                     PyErr_Format(PyExc_TypeError,
                                  "%.200s%s takes %s %d positional arguments"
-                                 " (%d given)",
+                                 " (%zd given)",
                                  (fname == NULL) ? "function" : fname,
                                  (fname == NULL) ? "" : "()",
                                  (min != INT_MAX) ? "at most" : "exactly",
@@ -1797,7 +1797,7 @@ vgetargskeywords(PyObject *args, PyObject *kwargs, const char *format,
     if (skip) {
         PyErr_Format(PyExc_TypeError,
                      "%.200s%s takes %s %d positional arguments"
-                     " (%d given)",
+                     " (%zd given)",
                      (fname == NULL) ? "function" : fname,
                      (fname == NULL) ? "" : "()",
                      (Py_MIN(pos, min) < i) ? "at least" : "exactly",
@@ -2103,7 +2103,7 @@ vgetargskeywordsfast_impl(PyObject *const *args, Py_ssize_t nargs,
         }
         else {
             PyErr_Format(PyExc_TypeError,
-                         "%.200s%s takes %s %d positional arguments (%d given)",
+                         "%.200s%s takes %s %d positional arguments (%zd given)",
                          (parser->fname == NULL) ? "function" : parser->fname,
                          (parser->fname == NULL) ? "" : "()",
                          (parser->min != INT_MAX) ? "at most" : "exactly",
@@ -2152,7 +2152,7 @@ vgetargskeywordsfast_impl(PyObject *const *args, Py_ssize_t nargs,
                 Py_ssize_t min = Py_MIN(pos, parser->min);
                 PyErr_Format(PyExc_TypeError,
                              "%.200s%s takes %s %d positional arguments"
-                             " (%d given)",
+                             " (%zd given)",
                              (parser->fname == NULL) ? "function" : parser->fname,
                              (parser->fname == NULL) ? "" : "()",
                              min < parser->max ? "at least" : "exactly",
diff --git a/Python/hamt.c b/Python/hamt.c
index 562f777ea0bf868..71a5ec87c5856a2 100644
--- a/Python/hamt.c
+++ b/Python/hamt.c
@@ -2003,7 +2003,7 @@ hamt_node_array_dump(PyHamtNode_Array *node,
             goto error;
         }
 
-        if (_hamt_dump_format(writer, "%d::\n", i)) {
+        if (_hamt_dump_format(writer, "%zd::\n", i)) {
             goto error;
         }
 
diff --git a/Python/pyarena.c b/Python/pyarena.c
index 103603fcdff32e1..d2aa8b8c3264dc6 100644
--- a/Python/pyarena.c
+++ b/Python/pyarena.c
@@ -160,7 +160,7 @@ PyArena_Free(PyArena *arena)
 #if defined(Py_DEBUG)
     /*
     fprintf(stderr,
-        "alloc=%d size=%d blocks=%d block_size=%d big=%d objects=%d\n",
+        "alloc=%zu size=%zu blocks=%zu block_size=%zu big=%zu objects=%zu\n",
         arena->total_allocs, arena->total_size, arena->total_blocks,
         arena->total_block_size, arena->total_big_blocks,
         PyList_Size(arena->a_objects));