Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 336 insertions, 336 deletions

diff --git a/contrib/tools/python3/src/Modules/_collectionsmodule.c b/contrib/tools/python3/src/Modules/_collectionsmodule.c
index dac8c1589b..2e19b83dce 100644
--- a/contrib/tools/python3/src/Modules/_collectionsmodule.c
+++ b/contrib/tools/python3/src/Modules/_collectionsmodule.c
@@ -1,21 +1,21 @@
 #include "Python.h"
-#include "structmember.h"         // PyMemberDef 
+#include "structmember.h"         // PyMemberDef
 
 #ifdef STDC_HEADERS
 #include <stddef.h>
 #else
-#include <sys/types.h>            // size_t 
+#include <sys/types.h>            // size_t
 #endif
 
-/*[clinic input] 
-module _collections 
-class _tuplegetter "_tuplegetterobject *" "&tuplegetter_type" 
-[clinic start generated code]*/ 
-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=a8ece4ccad7e30ac]*/ 
- 
-static PyTypeObject tuplegetter_type; 
-#include "clinic/_collectionsmodule.c.h" 
- 
+/*[clinic input]
+module _collections
+class _tuplegetter "_tuplegetterobject *" "&tuplegetter_type"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=a8ece4ccad7e30ac]*/
+
+static PyTypeObject tuplegetter_type;
+#include "clinic/_collectionsmodule.c.h"
+
 /* collections module implementation of a deque() datatype
    Written and maintained by Raymond D. Hettinger <python@rcn.com>
 */
@@ -172,7 +172,7 @@ deque_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     MARK_END(b->rightlink);
 
     assert(BLOCKLEN >= 2);
-    Py_SET_SIZE(deque, 0); 
+    Py_SET_SIZE(deque, 0);
     deque->leftblock = b;
     deque->rightblock = b;
     deque->leftindex = CENTER + 1;
@@ -196,7 +196,7 @@ deque_pop(dequeobject *deque, PyObject *unused)
     }
     item = deque->rightblock->data[deque->rightindex];
     deque->rightindex--;
-    Py_SET_SIZE(deque, Py_SIZE(deque) - 1); 
+    Py_SET_SIZE(deque, Py_SIZE(deque) - 1);
     deque->state++;
 
     if (deque->rightindex < 0) {
@@ -234,7 +234,7 @@ deque_popleft(dequeobject *deque, PyObject *unused)
     assert(deque->leftblock != NULL);
     item = deque->leftblock->data[deque->leftindex];
     deque->leftindex++;
-    Py_SET_SIZE(deque, Py_SIZE(deque) - 1); 
+    Py_SET_SIZE(deque, Py_SIZE(deque) - 1);
     deque->state++;
 
     if (deque->leftindex == BLOCKLEN) {
@@ -273,7 +273,7 @@ PyDoc_STRVAR(popleft_doc, "Remove and return the leftmost element.");
 
 #define NEEDS_TRIM(deque, maxlen) ((size_t)(maxlen) < (size_t)(Py_SIZE(deque)))
 
-static inline int 
+static inline int
 deque_append_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen)
 {
     if (deque->rightindex == BLOCKLEN - 1) {
@@ -287,7 +287,7 @@ deque_append_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen)
         MARK_END(b->rightlink);
         deque->rightindex = -1;
     }
-    Py_SET_SIZE(deque, Py_SIZE(deque) + 1); 
+    Py_SET_SIZE(deque, Py_SIZE(deque) + 1);
     deque->rightindex++;
     deque->rightblock->data[deque->rightindex] = item;
     if (NEEDS_TRIM(deque, maxlen)) {
@@ -310,7 +310,7 @@ deque_append(dequeobject *deque, PyObject *item)
 
 PyDoc_STRVAR(append_doc, "Add an element to the right side of the deque.");
 
-static inline int 
+static inline int
 deque_appendleft_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen)
 {
     if (deque->leftindex == 0) {
@@ -324,7 +324,7 @@ deque_appendleft_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen)
         MARK_END(b->leftlink);
         deque->leftindex = BLOCKLEN;
     }
-    Py_SET_SIZE(deque, Py_SIZE(deque) + 1); 
+    Py_SET_SIZE(deque, Py_SIZE(deque) + 1);
     deque->leftindex--;
     deque->leftblock->data[deque->leftindex] = item;
     if (NEEDS_TRIM(deque, deque->maxlen)) {
@@ -412,10 +412,10 @@ deque_extend(dequeobject *deque, PyObject *iterable)
 
     iternext = *Py_TYPE(it)->tp_iternext;
     while ((item = iternext(it)) != NULL) {
-        if (deque_append_internal(deque, item, maxlen) == -1) { 
-            Py_DECREF(item); 
-            Py_DECREF(it); 
-            return NULL; 
+        if (deque_append_internal(deque, item, maxlen) == -1) {
+            Py_DECREF(item);
+            Py_DECREF(it);
+            return NULL;
         }
     }
     return finalize_iterator(it);
@@ -459,10 +459,10 @@ deque_extendleft(dequeobject *deque, PyObject *iterable)
 
     iternext = *Py_TYPE(it)->tp_iternext;
     while ((item = iternext(it)) != NULL) {
-        if (deque_appendleft_internal(deque, item, maxlen) == -1) { 
-            Py_DECREF(item); 
-            Py_DECREF(it); 
-            return NULL; 
+        if (deque_appendleft_internal(deque, item, maxlen) == -1) {
+            Py_DECREF(item);
+            Py_DECREF(it);
+            return NULL;
         }
     }
     return finalize_iterator(it);
@@ -485,11 +485,11 @@ deque_inplace_concat(dequeobject *deque, PyObject *other)
 }
 
 static PyObject *
-deque_copy(PyObject *deque, PyObject *Py_UNUSED(ignored)) 
+deque_copy(PyObject *deque, PyObject *Py_UNUSED(ignored))
 {
     PyObject *result;
     dequeobject *old_deque = (dequeobject *)deque;
-    if (Py_IS_TYPE(deque, &deque_type)) { 
+    if (Py_IS_TYPE(deque, &deque_type)) {
         dequeobject *new_deque;
         PyObject *rv;
 
@@ -512,7 +512,7 @@ deque_copy(PyObject *deque, PyObject *Py_UNUSED(ignored))
         return NULL;
     }
     if (old_deque->maxlen < 0)
-        result = PyObject_CallOneArg((PyObject *)(Py_TYPE(deque)), deque); 
+        result = PyObject_CallOneArg((PyObject *)(Py_TYPE(deque)), deque);
     else
         result = PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "Oi",
                                        deque, old_deque->maxlen, NULL);
@@ -539,12 +539,12 @@ deque_concat(dequeobject *deque, PyObject *other)
         if (rv == 0) {
             PyErr_Format(PyExc_TypeError,
                          "can only concatenate deque (not \"%.200s\") to deque",
-                         Py_TYPE(other)->tp_name); 
+                         Py_TYPE(other)->tp_name);
         }
         return NULL;
     }
 
-    new_deque = deque_copy((PyObject *)deque, NULL); 
+    new_deque = deque_copy((PyObject *)deque, NULL);
     if (new_deque == NULL)
         return NULL;
     result = deque_extend((dequeobject *)new_deque, other);
@@ -597,7 +597,7 @@ deque_clear(dequeobject *deque)
     /* Set the deque to be empty using the newly allocated block */
     MARK_END(b->leftlink);
     MARK_END(b->rightlink);
-    Py_SET_SIZE(deque, 0); 
+    Py_SET_SIZE(deque, 0);
     deque->leftblock = b;
     deque->rightblock = b;
     deque->leftindex = CENTER + 1;
@@ -641,7 +641,7 @@ deque_clear(dequeobject *deque)
 }
 
 static PyObject *
-deque_clearmethod(dequeobject *deque, PyObject *Py_UNUSED(ignored)) 
+deque_clearmethod(dequeobject *deque, PyObject *Py_UNUSED(ignored))
 {
     deque_clear(deque);
     Py_RETURN_NONE;
@@ -680,7 +680,7 @@ deque_inplace_repeat(dequeobject *deque, Py_ssize_t n)
             if (deque->rightindex == BLOCKLEN - 1) {
                 block *b = newblock();
                 if (b == NULL) {
-                    Py_SET_SIZE(deque, Py_SIZE(deque) + i); 
+                    Py_SET_SIZE(deque, Py_SIZE(deque) + i);
                     return NULL;
                 }
                 b->leftlink = deque->rightblock;
@@ -700,7 +700,7 @@ deque_inplace_repeat(dequeobject *deque, Py_ssize_t n)
                 deque->rightblock->data[deque->rightindex] = item;
             }
         }
-        Py_SET_SIZE(deque, Py_SIZE(deque) + i); 
+        Py_SET_SIZE(deque, Py_SIZE(deque) + i);
         Py_INCREF(deque);
         return (PyObject *)deque;
     }
@@ -736,7 +736,7 @@ deque_repeat(dequeobject *deque, Py_ssize_t n)
     dequeobject *new_deque;
     PyObject *rv;
 
-    new_deque = (dequeobject *)deque_copy((PyObject *) deque, NULL); 
+    new_deque = (dequeobject *)deque_copy((PyObject *) deque, NULL);
     if (new_deque == NULL)
         return NULL;
     rv = deque_inplace_repeat(new_deque, n);
@@ -965,9 +965,9 @@ deque_count(dequeobject *deque, PyObject *v)
     while (--n >= 0) {
         CHECK_NOT_END(b);
         item = b->data[index];
-        Py_INCREF(item); 
+        Py_INCREF(item);
         cmp = PyObject_RichCompareBool(item, v, Py_EQ);
-        Py_DECREF(item); 
+        Py_DECREF(item);
         if (cmp < 0)
             return NULL;
         count += cmp;
@@ -1004,9 +1004,9 @@ deque_contains(dequeobject *deque, PyObject *v)
     while (--n >= 0) {
         CHECK_NOT_END(b);
         item = b->data[index];
-        Py_INCREF(item); 
+        Py_INCREF(item);
         cmp = PyObject_RichCompareBool(item, v, Py_EQ);
-        Py_DECREF(item); 
+        Py_DECREF(item);
         if (cmp) {
             return cmp;
         }
@@ -1062,10 +1062,10 @@ deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs)
         start = stop;
     assert(0 <= start && start <= stop && stop <= Py_SIZE(deque));
 
-    for (i=0 ; i < start - BLOCKLEN ; i += BLOCKLEN) { 
-        b = b->rightlink; 
-    } 
-    for ( ; i < start ; i++) { 
+    for (i=0 ; i < start - BLOCKLEN ; i += BLOCKLEN) {
+        b = b->rightlink;
+    }
+    for ( ; i < start ; i++) {
         index++;
         if (index == BLOCKLEN) {
             b = b->rightlink;
@@ -1467,13 +1467,13 @@ deque_init(dequeobject *deque, PyObject *args, PyObject *kwdargs)
     Py_ssize_t maxlen = -1;
     char *kwlist[] = {"iterable", "maxlen", 0};
 
-    if (kwdargs == NULL && PyTuple_GET_SIZE(args) <= 2) { 
-        if (PyTuple_GET_SIZE(args) > 0) { 
-            iterable = PyTuple_GET_ITEM(args, 0); 
-        } 
-        if (PyTuple_GET_SIZE(args) > 1) { 
-            maxlenobj = PyTuple_GET_ITEM(args, 1); 
-        } 
+    if (kwdargs == NULL && PyTuple_GET_SIZE(args) <= 2) {
+        if (PyTuple_GET_SIZE(args) > 0) {
+            iterable = PyTuple_GET_ITEM(args, 0);
+        }
+        if (PyTuple_GET_SIZE(args) > 1) {
+            maxlenobj = PyTuple_GET_ITEM(args, 1);
+        }
     } else {
         if (!PyArg_ParseTupleAndKeywords(args, kwdargs, "|OO:deque", kwlist,
                                          &iterable, &maxlenobj))
@@ -1568,7 +1568,7 @@ static PyNumberMethods deque_as_number = {
  };
 
 static PyObject *deque_iter(dequeobject *deque);
-static PyObject *deque_reviter(dequeobject *deque, PyObject *Py_UNUSED(ignored)); 
+static PyObject *deque_reviter(dequeobject *deque, PyObject *Py_UNUSED(ignored));
 PyDoc_STRVAR(reversed_doc,
     "D.__reversed__() -- return a reverse iterator over the deque");
 
@@ -1579,9 +1579,9 @@ static PyMethodDef deque_methods[] = {
         METH_O,                  appendleft_doc},
     {"clear",                   (PyCFunction)deque_clearmethod,
         METH_NOARGS,             clear_doc},
-    {"__copy__",                deque_copy, 
+    {"__copy__",                deque_copy,
         METH_NOARGS,             copy_doc},
-    {"copy",                    deque_copy, 
+    {"copy",                    deque_copy,
         METH_NOARGS,             copy_doc},
     {"count",                   (PyCFunction)deque_count,
         METH_O,                  count_doc},
@@ -1589,9 +1589,9 @@ static PyMethodDef deque_methods[] = {
         METH_O,                  extend_doc},
     {"extendleft",              (PyCFunction)deque_extendleft,
         METH_O,                  extendleft_doc},
-    {"index",                   (PyCFunction)(void(*)(void))deque_index, 
+    {"index",                   (PyCFunction)(void(*)(void))deque_index,
         METH_FASTCALL,            index_doc},
-    {"insert",                  (PyCFunction)(void(*)(void))deque_insert, 
+    {"insert",                  (PyCFunction)(void(*)(void))deque_insert,
         METH_FASTCALL,            insert_doc},
     {"pop",                     (PyCFunction)deque_pop,
         METH_NOARGS,             pop_doc},
@@ -1605,12 +1605,12 @@ static PyMethodDef deque_methods[] = {
         METH_NOARGS,             reversed_doc},
     {"reverse",                 (PyCFunction)deque_reverse,
         METH_NOARGS,             reverse_doc},
-    {"rotate",                  (PyCFunction)(void(*)(void))deque_rotate, 
+    {"rotate",                  (PyCFunction)(void(*)(void))deque_rotate,
         METH_FASTCALL,            rotate_doc},
     {"__sizeof__",              (PyCFunction)deque_sizeof,
         METH_NOARGS,             sizeof_doc},
-    {"__class_getitem__",       (PyCFunction)Py_GenericAlias, 
-        METH_O|METH_CLASS,       PyDoc_STR("See PEP 585")}, 
+    {"__class_getitem__",       (PyCFunction)Py_GenericAlias,
+        METH_O|METH_CLASS,       PyDoc_STR("See PEP 585")},
     {NULL,              NULL}   /* sentinel */
 };
 
@@ -1626,10 +1626,10 @@ static PyTypeObject deque_type = {
     0,                                  /* tp_itemsize */
     /* methods */
     (destructor)deque_dealloc,          /* tp_dealloc */
-    0,                                  /* tp_vectorcall_offset */ 
+    0,                                  /* tp_vectorcall_offset */
     0,                                  /* tp_getattr */
     0,                                  /* tp_setattr */
-    0,                                  /* tp_as_async */ 
+    0,                                  /* tp_as_async */
     deque_repr,                         /* tp_repr */
     &deque_as_number,                   /* tp_as_number */
     &deque_as_sequence,                 /* tp_as_sequence */
@@ -1768,7 +1768,7 @@ dequeiter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 }
 
 static PyObject *
-dequeiter_len(dequeiterobject *it, PyObject *Py_UNUSED(ignored)) 
+dequeiter_len(dequeiterobject *it, PyObject *Py_UNUSED(ignored))
 {
     return PyLong_FromSsize_t(it->counter);
 }
@@ -1776,7 +1776,7 @@ dequeiter_len(dequeiterobject *it, PyObject *Py_UNUSED(ignored))
 PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
 
 static PyObject *
-dequeiter_reduce(dequeiterobject *it, PyObject *Py_UNUSED(ignored)) 
+dequeiter_reduce(dequeiterobject *it, PyObject *Py_UNUSED(ignored))
 {
     return Py_BuildValue("O(On)", Py_TYPE(it), it->deque, Py_SIZE(it->deque) - it->counter);
 }
@@ -1794,10 +1794,10 @@ static PyTypeObject dequeiter_type = {
     0,                                          /* tp_itemsize */
     /* methods */
     (destructor)dequeiter_dealloc,              /* tp_dealloc */
-    0,                                          /* tp_vectorcall_offset */ 
+    0,                                          /* tp_vectorcall_offset */
     0,                                          /* tp_getattr */
     0,                                          /* tp_setattr */
-    0,                                          /* tp_as_async */ 
+    0,                                          /* tp_as_async */
     0,                                          /* tp_repr */
     0,                                          /* tp_as_number */
     0,                                          /* tp_as_sequence */
@@ -1835,7 +1835,7 @@ static PyTypeObject dequeiter_type = {
 static PyTypeObject dequereviter_type;
 
 static PyObject *
-deque_reviter(dequeobject *deque, PyObject *Py_UNUSED(ignored)) 
+deque_reviter(dequeobject *deque, PyObject *Py_UNUSED(ignored))
 {
     dequeiterobject *it;
 
@@ -1890,7 +1890,7 @@ dequereviter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         return NULL;
     assert(type == &dequereviter_type);
 
-    it = (dequeiterobject*)deque_reviter((dequeobject *)deque, NULL); 
+    it = (dequeiterobject*)deque_reviter((dequeobject *)deque, NULL);
     if (!it)
         return NULL;
     /* consume items from the queue */
@@ -1916,10 +1916,10 @@ static PyTypeObject dequereviter_type = {
     0,                                          /* tp_itemsize */
     /* methods */
     (destructor)dequeiter_dealloc,              /* tp_dealloc */
-    0,                                          /* tp_vectorcall_offset */ 
+    0,                                          /* tp_vectorcall_offset */
     0,                                          /* tp_getattr */
     0,                                          /* tp_setattr */
-    0,                                          /* tp_as_async */ 
+    0,                                          /* tp_as_async */
     0,                                          /* tp_repr */
     0,                                          /* tp_as_number */
     0,                                          /* tp_as_sequence */
@@ -1982,7 +1982,7 @@ defdict_missing(defdictobject *dd, PyObject *key)
         Py_DECREF(tup);
         return NULL;
     }
-    value = _PyObject_CallNoArg(factory); 
+    value = _PyObject_CallNoArg(factory);
     if (value == NULL)
         return value;
     if (PyObject_SetItem((PyObject *)dd, key, value) < 0) {
@@ -1992,27 +1992,27 @@ defdict_missing(defdictobject *dd, PyObject *key)
     return value;
 }
 
-static inline PyObject* 
-new_defdict(defdictobject *dd, PyObject *arg) 
-{ 
-    return PyObject_CallFunctionObjArgs((PyObject*)Py_TYPE(dd), 
-        dd->default_factory ? dd->default_factory : Py_None, arg, NULL); 
-} 
- 
+static inline PyObject*
+new_defdict(defdictobject *dd, PyObject *arg)
+{
+    return PyObject_CallFunctionObjArgs((PyObject*)Py_TYPE(dd),
+        dd->default_factory ? dd->default_factory : Py_None, arg, NULL);
+}
+
 PyDoc_STRVAR(defdict_copy_doc, "D.copy() -> a shallow copy of D.");
 
 static PyObject *
-defdict_copy(defdictobject *dd, PyObject *Py_UNUSED(ignored)) 
+defdict_copy(defdictobject *dd, PyObject *Py_UNUSED(ignored))
 {
     /* 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().
     */
-    return new_defdict(dd, (PyObject*)dd); 
+    return new_defdict(dd, (PyObject*)dd);
 }
 
 static PyObject *
-defdict_reduce(defdictobject *dd, PyObject *Py_UNUSED(ignored)) 
+defdict_reduce(defdictobject *dd, PyObject *Py_UNUSED(ignored))
 {
     /* __reduce__ must return a 5-tuple as follows:
 
@@ -2048,7 +2048,7 @@ defdict_reduce(defdictobject *dd, PyObject *Py_UNUSED(ignored))
         args = PyTuple_Pack(1, dd->default_factory);
     if (args == NULL)
         return NULL;
-    items = _PyObject_CallMethodIdNoArgs((PyObject *)dd, &PyId_items); 
+    items = _PyObject_CallMethodIdNoArgs((PyObject *)dd, &PyId_items);
     if (items == NULL) {
         Py_DECREF(args);
         return NULL;
@@ -2076,8 +2076,8 @@ static PyMethodDef defdict_methods[] = {
      defdict_copy_doc},
     {"__reduce__", (PyCFunction)defdict_reduce, METH_NOARGS,
      reduce_doc},
-    {"__class_getitem__", (PyCFunction)Py_GenericAlias, METH_O|METH_CLASS, 
-     PyDoc_STR("See PEP 585")}, 
+    {"__class_getitem__", (PyCFunction)Py_GenericAlias, METH_O|METH_CLASS,
+     PyDoc_STR("See PEP 585")},
     {NULL}
 };
 
@@ -2134,38 +2134,38 @@ defdict_repr(defdictobject *dd)
     return result;
 }
 
-static PyObject* 
-defdict_or(PyObject* left, PyObject* right) 
-{ 
-    PyObject *self, *other; 
-    if (PyObject_TypeCheck(left, &defdict_type)) { 
-        self = left; 
-        other = right; 
-    } 
-    else { 
-        self = right; 
-        other = left; 
-    } 
-    if (!PyDict_Check(other)) { 
-        Py_RETURN_NOTIMPLEMENTED; 
-    } 
-    // Like copy(), this calls the object's class. 
-    // Override __or__/__ror__ for subclasses with different constructors. 
-    PyObject *new = new_defdict((defdictobject*)self, left); 
-    if (!new) { 
-        return NULL; 
-    } 
-    if (PyDict_Update(new, right)) { 
-        Py_DECREF(new); 
-        return NULL; 
-    } 
-    return new; 
-} 
- 
-static PyNumberMethods defdict_as_number = { 
-    .nb_or = defdict_or, 
-}; 
- 
+static PyObject*
+defdict_or(PyObject* left, PyObject* right)
+{
+    PyObject *self, *other;
+    if (PyObject_TypeCheck(left, &defdict_type)) {
+        self = left;
+        other = right;
+    }
+    else {
+        self = right;
+        other = left;
+    }
+    if (!PyDict_Check(other)) {
+        Py_RETURN_NOTIMPLEMENTED;
+    }
+    // Like copy(), this calls the object's class.
+    // Override __or__/__ror__ for subclasses with different constructors.
+    PyObject *new = new_defdict((defdictobject*)self, left);
+    if (!new) {
+        return NULL;
+    }
+    if (PyDict_Update(new, right)) {
+        Py_DECREF(new);
+        return NULL;
+    }
+    return new;
+}
+
+static PyNumberMethods defdict_as_number = {
+    .nb_or = defdict_or,
+};
+
 static int
 defdict_traverse(PyObject *self, visitproc visit, void *arg)
 {
@@ -2213,7 +2213,7 @@ defdict_init(PyObject *self, PyObject *args, PyObject *kwds)
 }
 
 PyDoc_STRVAR(defdict_doc,
-"defaultdict(default_factory=None, /, [...]) --> dict with default factory\n\ 
+"defaultdict(default_factory=None, /, [...]) --> 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\
@@ -2232,12 +2232,12 @@ static PyTypeObject defdict_type = {
     0,                                  /* tp_itemsize */
     /* methods */
     (destructor)defdict_dealloc,        /* tp_dealloc */
-    0,                                  /* tp_vectorcall_offset */ 
+    0,                                  /* tp_vectorcall_offset */
     0,                                  /* tp_getattr */
     0,                                  /* tp_setattr */
-    0,                                  /* tp_as_async */ 
+    0,                                  /* tp_as_async */
     (reprfunc)defdict_repr,             /* tp_repr */
-    &defdict_as_number,                 /* tp_as_number */ 
+    &defdict_as_number,                 /* tp_as_number */
     0,                                  /* tp_as_sequence */
     0,                                  /* tp_as_mapping */
     0,                                  /* tp_hash */
@@ -2271,24 +2271,24 @@ static PyTypeObject defdict_type = {
 
 /* helper function for Counter  *********************************************/
 
-/*[clinic input] 
-_collections._count_elements 
+/*[clinic input]
+_collections._count_elements
+
+    mapping: object
+    iterable: object
+    /
+
+Count elements in the iterable, updating the mapping
+[clinic start generated code]*/
 
-    mapping: object 
-    iterable: object 
-    / 
- 
-Count elements in the iterable, updating the mapping 
-[clinic start generated code]*/ 
- 
 static PyObject *
-_collections__count_elements_impl(PyObject *module, PyObject *mapping, 
-                                  PyObject *iterable) 
-/*[clinic end generated code: output=7e0c1789636b3d8f input=e79fad04534a0b45]*/ 
+_collections__count_elements_impl(PyObject *module, PyObject *mapping,
+                                  PyObject *iterable)
+/*[clinic end generated code: output=7e0c1789636b3d8f input=e79fad04534a0b45]*/
 {
     _Py_IDENTIFIER(get);
     _Py_IDENTIFIER(__setitem__);
-    PyObject *it, *oldval; 
+    PyObject *it, *oldval;
     PyObject *newval = NULL;
     PyObject *key = NULL;
     PyObject *bound_get = NULL;
@@ -2387,222 +2387,222 @@ done:
     Py_RETURN_NONE;
 }
 
-/* Helper function for namedtuple() ************************************/ 
- 
-typedef struct { 
-    PyObject_HEAD 
-    Py_ssize_t index; 
-    PyObject* doc; 
-} _tuplegetterobject; 
- 
-/*[clinic input] 
-@classmethod 
-_tuplegetter.__new__ as tuplegetter_new 
- 
-    index: Py_ssize_t 
-    doc: object 
-    / 
-[clinic start generated code]*/ 
- 
-static PyObject * 
-tuplegetter_new_impl(PyTypeObject *type, Py_ssize_t index, PyObject *doc) 
-/*[clinic end generated code: output=014be444ad80263f input=87c576a5bdbc0bbb]*/ 
-{ 
-    _tuplegetterobject* self; 
-    self = (_tuplegetterobject *)type->tp_alloc(type, 0); 
-    if (self == NULL) { 
-        return NULL; 
-    } 
-    self->index = index; 
-    Py_INCREF(doc); 
-    self->doc = doc; 
-    return (PyObject *)self; 
-} 
- 
-static PyObject * 
-tuplegetter_descr_get(PyObject *self, PyObject *obj, PyObject *type) 
-{ 
-    Py_ssize_t index = ((_tuplegetterobject*)self)->index; 
-    PyObject *result; 
- 
-    if (obj == NULL) { 
-        Py_INCREF(self); 
-        return self; 
-    } 
-    if (!PyTuple_Check(obj)) { 
-        if (obj == Py_None) { 
-            Py_INCREF(self); 
-            return self; 
-        } 
-        PyErr_Format(PyExc_TypeError, 
-                     "descriptor for index '%zd' for tuple subclasses " 
-                     "doesn't apply to '%s' object", 
-                     index, 
-                     Py_TYPE(obj)->tp_name); 
-        return NULL; 
-    } 
- 
-    if (!valid_index(index, PyTuple_GET_SIZE(obj))) { 
-        PyErr_SetString(PyExc_IndexError, "tuple index out of range"); 
-        return NULL; 
-    } 
- 
-    result = PyTuple_GET_ITEM(obj, index); 
-    Py_INCREF(result); 
-    return result; 
-} 
- 
-static int 
-tuplegetter_descr_set(PyObject *self, PyObject *obj, PyObject *value) 
-{ 
-    if (value == NULL) { 
-        PyErr_SetString(PyExc_AttributeError, "can't delete attribute"); 
-    } else { 
-        PyErr_SetString(PyExc_AttributeError, "can't set attribute"); 
-    } 
-    return -1; 
-} 
- 
-static int 
-tuplegetter_traverse(PyObject *self, visitproc visit, void *arg) 
-{ 
-    _tuplegetterobject *tuplegetter = (_tuplegetterobject *)self; 
-    Py_VISIT(tuplegetter->doc); 
-    return 0; 
-} 
- 
-static int 
-tuplegetter_clear(PyObject *self) 
-{ 
-    _tuplegetterobject *tuplegetter = (_tuplegetterobject *)self; 
-    Py_CLEAR(tuplegetter->doc); 
-    return 0; 
-} 
- 
-static void 
-tuplegetter_dealloc(_tuplegetterobject *self) 
-{ 
-    PyObject_GC_UnTrack(self); 
-    tuplegetter_clear((PyObject*)self); 
-    Py_TYPE(self)->tp_free((PyObject*)self); 
-} 
- 
-static PyObject* 
-tuplegetter_reduce(_tuplegetterobject *self, PyObject *Py_UNUSED(ignored)) 
-{ 
-    return Py_BuildValue("(O(nO))", (PyObject*) Py_TYPE(self), self->index, self->doc); 
-} 
- 
-static PyObject* 
-tuplegetter_repr(_tuplegetterobject *self) 
-{ 
-    return PyUnicode_FromFormat("%s(%zd, %R)", 
-                                _PyType_Name(Py_TYPE(self)), 
-                                self->index, self->doc); 
-} 
- 
- 
-static PyMemberDef tuplegetter_members[] = { 
-    {"__doc__",  T_OBJECT, offsetof(_tuplegetterobject, doc), 0}, 
-    {0} 
-}; 
- 
-static PyMethodDef tuplegetter_methods[] = { 
-    {"__reduce__", (PyCFunction)tuplegetter_reduce, METH_NOARGS, NULL}, 
-    {NULL}, 
-}; 
- 
-static PyTypeObject tuplegetter_type = { 
-    PyVarObject_HEAD_INIT(NULL, 0) 
-    "_collections._tuplegetter",                /* tp_name */ 
-    sizeof(_tuplegetterobject),                 /* tp_basicsize */ 
-    0,                                          /* tp_itemsize */ 
-    /* methods */ 
-    (destructor)tuplegetter_dealloc,            /* tp_dealloc */ 
-    0,                                          /* tp_vectorcall_offset */ 
-    0,                                          /* tp_getattr */ 
-    0,                                          /* tp_setattr */ 
-    0,                                          /* tp_as_async */ 
-    (reprfunc)tuplegetter_repr,                 /* tp_repr */ 
-    0,                                          /* tp_as_number */ 
-    0,                                          /* tp_as_sequence */ 
-    0,                                          /* tp_as_mapping */ 
-    0,                                          /* tp_hash */ 
-    0,                                          /* tp_call */ 
-    0,                                          /* tp_str */ 
-    0,                                          /* tp_getattro */ 
-    0,                                          /* tp_setattro */ 
-    0,                                          /* tp_as_buffer */ 
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,    /* tp_flags */ 
-    0,                                          /* tp_doc */ 
-    (traverseproc)tuplegetter_traverse,         /* tp_traverse */ 
-    (inquiry)tuplegetter_clear,                 /* tp_clear */ 
-    0,                                          /* tp_richcompare */ 
-    0,                                          /* tp_weaklistoffset */ 
-    0,                                          /* tp_iter */ 
-    0,                                          /* tp_iternext */ 
-    tuplegetter_methods,                        /* tp_methods */ 
-    tuplegetter_members,                        /* tp_members */ 
-    0,                                          /* tp_getset */ 
-    0,                                          /* tp_base */ 
-    0,                                          /* tp_dict */ 
-    tuplegetter_descr_get,                      /* tp_descr_get */ 
-    tuplegetter_descr_set,                      /* tp_descr_set */ 
-    0,                                          /* tp_dictoffset */ 
-    0,                                          /* tp_init */ 
-    0,                                          /* tp_alloc */ 
-    tuplegetter_new,                            /* tp_new */ 
-    0, 
-}; 
- 
- 
+/* Helper function for namedtuple() ************************************/
+
+typedef struct {
+    PyObject_HEAD
+    Py_ssize_t index;
+    PyObject* doc;
+} _tuplegetterobject;
+
+/*[clinic input]
+@classmethod
+_tuplegetter.__new__ as tuplegetter_new
+
+    index: Py_ssize_t
+    doc: object
+    /
+[clinic start generated code]*/
+
+static PyObject *
+tuplegetter_new_impl(PyTypeObject *type, Py_ssize_t index, PyObject *doc)
+/*[clinic end generated code: output=014be444ad80263f input=87c576a5bdbc0bbb]*/
+{
+    _tuplegetterobject* self;
+    self = (_tuplegetterobject *)type->tp_alloc(type, 0);
+    if (self == NULL) {
+        return NULL;
+    }
+    self->index = index;
+    Py_INCREF(doc);
+    self->doc = doc;
+    return (PyObject *)self;
+}
+
+static PyObject *
+tuplegetter_descr_get(PyObject *self, PyObject *obj, PyObject *type)
+{
+    Py_ssize_t index = ((_tuplegetterobject*)self)->index;
+    PyObject *result;
+
+    if (obj == NULL) {
+        Py_INCREF(self);
+        return self;
+    }
+    if (!PyTuple_Check(obj)) {
+        if (obj == Py_None) {
+            Py_INCREF(self);
+            return self;
+        }
+        PyErr_Format(PyExc_TypeError,
+                     "descriptor for index '%zd' for tuple subclasses "
+                     "doesn't apply to '%s' object",
+                     index,
+                     Py_TYPE(obj)->tp_name);
+        return NULL;
+    }
+
+    if (!valid_index(index, PyTuple_GET_SIZE(obj))) {
+        PyErr_SetString(PyExc_IndexError, "tuple index out of range");
+        return NULL;
+    }
+
+    result = PyTuple_GET_ITEM(obj, index);
+    Py_INCREF(result);
+    return result;
+}
+
+static int
+tuplegetter_descr_set(PyObject *self, PyObject *obj, PyObject *value)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
+    } else {
+        PyErr_SetString(PyExc_AttributeError, "can't set attribute");
+    }
+    return -1;
+}
+
+static int
+tuplegetter_traverse(PyObject *self, visitproc visit, void *arg)
+{
+    _tuplegetterobject *tuplegetter = (_tuplegetterobject *)self;
+    Py_VISIT(tuplegetter->doc);
+    return 0;
+}
+
+static int
+tuplegetter_clear(PyObject *self)
+{
+    _tuplegetterobject *tuplegetter = (_tuplegetterobject *)self;
+    Py_CLEAR(tuplegetter->doc);
+    return 0;
+}
+
+static void
+tuplegetter_dealloc(_tuplegetterobject *self)
+{
+    PyObject_GC_UnTrack(self);
+    tuplegetter_clear((PyObject*)self);
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static PyObject*
+tuplegetter_reduce(_tuplegetterobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return Py_BuildValue("(O(nO))", (PyObject*) Py_TYPE(self), self->index, self->doc);
+}
+
+static PyObject*
+tuplegetter_repr(_tuplegetterobject *self)
+{
+    return PyUnicode_FromFormat("%s(%zd, %R)",
+                                _PyType_Name(Py_TYPE(self)),
+                                self->index, self->doc);
+}
+
+
+static PyMemberDef tuplegetter_members[] = {
+    {"__doc__",  T_OBJECT, offsetof(_tuplegetterobject, doc), 0},
+    {0}
+};
+
+static PyMethodDef tuplegetter_methods[] = {
+    {"__reduce__", (PyCFunction)tuplegetter_reduce, METH_NOARGS, NULL},
+    {NULL},
+};
+
+static PyTypeObject tuplegetter_type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "_collections._tuplegetter",                /* tp_name */
+    sizeof(_tuplegetterobject),                 /* tp_basicsize */
+    0,                                          /* tp_itemsize */
+    /* methods */
+    (destructor)tuplegetter_dealloc,            /* tp_dealloc */
+    0,                                          /* tp_vectorcall_offset */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_as_async */
+    (reprfunc)tuplegetter_repr,                 /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    0,                                          /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,    /* tp_flags */
+    0,                                          /* tp_doc */
+    (traverseproc)tuplegetter_traverse,         /* tp_traverse */
+    (inquiry)tuplegetter_clear,                 /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    tuplegetter_methods,                        /* tp_methods */
+    tuplegetter_members,                        /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    tuplegetter_descr_get,                      /* tp_descr_get */
+    tuplegetter_descr_set,                      /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    0,                                          /* tp_init */
+    0,                                          /* tp_alloc */
+    tuplegetter_new,                            /* tp_new */
+    0,
+};
+
+
 /* module level code ********************************************************/
 
-PyDoc_STRVAR(collections_doc, 
+PyDoc_STRVAR(collections_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 collections_methods[] = { 
-    _COLLECTIONS__COUNT_ELEMENTS_METHODDEF 
+static struct PyMethodDef collections_methods[] = {
+    _COLLECTIONS__COUNT_ELEMENTS_METHODDEF
     {NULL,       NULL}          /* sentinel */
 };
 
-static int 
-collections_exec(PyObject *module) { 
-    PyTypeObject *typelist[] = { 
-        &deque_type, 
-        &defdict_type, 
-        &PyODict_Type, 
-        &dequeiter_type, 
-        &dequereviter_type, 
-        &tuplegetter_type 
-    }; 
- 
-    defdict_type.tp_base = &PyDict_Type; 
- 
-    for (size_t i = 0; i < Py_ARRAY_LENGTH(typelist); i++) { 
-        if (PyModule_AddType(module, typelist[i]) < 0) { 
-            return -1; 
-        } 
-    } 
- 
-    return 0; 
-} 
- 
-static struct PyModuleDef_Slot collections_slots[] = { 
-    {Py_mod_exec, collections_exec}, 
-    {0, NULL} 
-}; 
- 
+static int
+collections_exec(PyObject *module) {
+    PyTypeObject *typelist[] = {
+        &deque_type,
+        &defdict_type,
+        &PyODict_Type,
+        &dequeiter_type,
+        &dequereviter_type,
+        &tuplegetter_type
+    };
+
+    defdict_type.tp_base = &PyDict_Type;
+
+    for (size_t i = 0; i < Py_ARRAY_LENGTH(typelist); i++) {
+        if (PyModule_AddType(module, typelist[i]) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+static struct PyModuleDef_Slot collections_slots[] = {
+    {Py_mod_exec, collections_exec},
+    {0, NULL}
+};
+
 static struct PyModuleDef _collectionsmodule = {
     PyModuleDef_HEAD_INIT,
     "_collections",
-    collections_doc, 
-    0, 
-    collections_methods, 
-    collections_slots, 
+    collections_doc,
+    0,
+    collections_methods,
+    collections_slots,
     NULL,
     NULL,
     NULL
@@ -2611,5 +2611,5 @@ static struct PyModuleDef _collectionsmodule = {
 PyMODINIT_FUNC
 PyInit__collections(void)
 {
-    return PyModuleDef_Init(&_collectionsmodule); 
+    return PyModuleDef_Init(&_collectionsmodule);
 }