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

24 files changed, 4358 insertions, 4358 deletions

diff --git a/contrib/tools/python3/src/Include/cpython/abstract.h b/contrib/tools/python3/src/Include/cpython/abstract.h
index 9a3737c42f..0f1304d26a 100644
--- a/contrib/tools/python3/src/Include/cpython/abstract.h
+++ b/contrib/tools/python3/src/Include/cpython/abstract.h
@@ -1,384 +1,384 @@
-#ifndef Py_CPYTHON_ABSTRACTOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-/* === Object Protocol ================================================== */ 
- 
-#ifdef PY_SSIZE_T_CLEAN 
-#  define _PyObject_CallMethodId _PyObject_CallMethodId_SizeT 
-#endif 
- 
-/* Convert keyword arguments from the FASTCALL (stack: C array, kwnames: tuple) 
-   format to a Python dictionary ("kwargs" dict). 
- 
-   The type of kwnames keys is not checked. The final function getting 
-   arguments is responsible to check if all keys are strings, for example using 
-   PyArg_ParseTupleAndKeywords() or PyArg_ValidateKeywordArguments(). 
- 
-   Duplicate keys are merged using the last value. If duplicate keys must raise 
-   an exception, the caller is responsible to implement an explicit keys on 
-   kwnames. */ 
-PyAPI_FUNC(PyObject *) _PyStack_AsDict( 
-    PyObject *const *values, 
-    PyObject *kwnames); 
- 
-/* Suggested size (number of positional arguments) for arrays of PyObject* 
-   allocated on a C stack to avoid allocating memory on the heap memory. Such 
-   array is used to pass positional arguments to call functions of the 
-   PyObject_Vectorcall() family. 
- 
-   The size is chosen to not abuse the C stack and so limit the risk of stack 
-   overflow. The size is also chosen to allow using the small stack for most 
-   function calls of the Python standard library. On 64-bit CPU, it allocates 
-   40 bytes on the stack. */ 
-#define _PY_FASTCALL_SMALL_STACK 5 
- 
-PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult( 
-    PyThreadState *tstate, 
-    PyObject *callable, 
-    PyObject *result, 
-    const char *where); 
- 
-/* === Vectorcall protocol (PEP 590) ============================= */ 
- 
-/* Call callable using tp_call. Arguments are like PyObject_Vectorcall() 
-   or PyObject_FastCallDict() (both forms are supported), 
-   except that nargs is plainly the number of arguments without flags. */ 
-PyAPI_FUNC(PyObject *) _PyObject_MakeTpCall( 
-    PyThreadState *tstate, 
-    PyObject *callable, 
-    PyObject *const *args, Py_ssize_t nargs, 
-    PyObject *keywords); 
- 
-#define PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) 
- 
-static inline Py_ssize_t 
-PyVectorcall_NARGS(size_t n) 
-{ 
-    return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET; 
-} 
- 
-static inline vectorcallfunc 
-PyVectorcall_Function(PyObject *callable) 
-{ 
-    PyTypeObject *tp; 
-    Py_ssize_t offset; 
-    vectorcallfunc ptr; 
- 
-    assert(callable != NULL); 
-    tp = Py_TYPE(callable); 
-    if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { 
-        return NULL; 
-    } 
-    assert(PyCallable_Check(callable)); 
-    offset = tp->tp_vectorcall_offset; 
-    assert(offset > 0); 
-    memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); 
-    return ptr; 
-} 
- 
-/* Call the callable object 'callable' with the "vectorcall" calling 
-   convention. 
- 
-   args is a C array for positional arguments. 
- 
-   nargsf is the number of positional arguments plus optionally the flag 
-   PY_VECTORCALL_ARGUMENTS_OFFSET which means that the caller is allowed to 
-   modify args[-1]. 
- 
-   kwnames is a tuple of keyword names. The values of the keyword arguments 
-   are stored in "args" after the positional arguments (note that the number 
-   of keyword arguments does not change nargsf). kwnames can also be NULL if 
-   there are no keyword arguments. 
- 
-   keywords must only contain strings and all keys must be unique. 
- 
-   Return the result on success. Raise an exception and return NULL on 
-   error. */ 
-static inline PyObject * 
-_PyObject_VectorcallTstate(PyThreadState *tstate, PyObject *callable, 
-                           PyObject *const *args, size_t nargsf, 
-                           PyObject *kwnames) 
-{ 
-    vectorcallfunc func; 
-    PyObject *res; 
- 
-    assert(kwnames == NULL || PyTuple_Check(kwnames)); 
-    assert(args != NULL || PyVectorcall_NARGS(nargsf) == 0); 
- 
-    func = PyVectorcall_Function(callable); 
-    if (func == NULL) { 
-        Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); 
-        return _PyObject_MakeTpCall(tstate, callable, args, nargs, kwnames); 
-    } 
-    res = func(callable, args, nargsf, kwnames); 
-    return _Py_CheckFunctionResult(tstate, callable, res, NULL); 
-} 
- 
-static inline PyObject * 
-PyObject_Vectorcall(PyObject *callable, PyObject *const *args, 
-                     size_t nargsf, PyObject *kwnames) 
-{ 
-    PyThreadState *tstate = PyThreadState_GET(); 
-    return _PyObject_VectorcallTstate(tstate, callable, 
-                                      args, nargsf, kwnames); 
-} 
- 
-// Backwards compatibility aliases for API that was provisional in Python 3.8 
-#define _PyObject_Vectorcall PyObject_Vectorcall 
-#define _PyObject_VectorcallMethod PyObject_VectorcallMethod 
-#define _PyObject_FastCallDict PyObject_VectorcallDict 
-#define _PyVectorcall_Function PyVectorcall_Function 
-#define _PyObject_CallOneArg PyObject_CallOneArg 
-#define _PyObject_CallMethodNoArgs PyObject_CallMethodNoArgs 
-#define _PyObject_CallMethodOneArg PyObject_CallMethodOneArg 
- 
-/* Same as PyObject_Vectorcall except that keyword arguments are passed as 
-   dict, which may be NULL if there are no keyword arguments. */ 
-PyAPI_FUNC(PyObject *) PyObject_VectorcallDict( 
-    PyObject *callable, 
-    PyObject *const *args, 
-    size_t nargsf, 
-    PyObject *kwargs); 
- 
-/* Call "callable" (which must support vectorcall) with positional arguments 
-   "tuple" and keyword arguments "dict". "dict" may also be NULL */ 
-PyAPI_FUNC(PyObject *) PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *dict); 
- 
-static inline PyObject * 
-_PyObject_FastCallTstate(PyThreadState *tstate, PyObject *func, PyObject *const *args, Py_ssize_t nargs) 
-{ 
-    return _PyObject_VectorcallTstate(tstate, func, args, (size_t)nargs, NULL); 
-} 
- 
-/* Same as PyObject_Vectorcall except without keyword arguments */ 
-static inline PyObject * 
-_PyObject_FastCall(PyObject *func, PyObject *const *args, Py_ssize_t nargs) 
-{ 
-    PyThreadState *tstate = PyThreadState_GET(); 
-    return _PyObject_FastCallTstate(tstate, func, args, nargs); 
-} 
- 
-/* Call a callable without any arguments 
-   Private static inline function variant of public function 
-   PyObject_CallNoArgs(). */ 
-static inline PyObject * 
-_PyObject_CallNoArg(PyObject *func) { 
-    PyThreadState *tstate = PyThreadState_GET(); 
-    return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); 
-} 
- 
-static inline PyObject * 
-PyObject_CallOneArg(PyObject *func, PyObject *arg) 
-{ 
-    PyObject *_args[2]; 
-    PyObject **args; 
-    PyThreadState *tstate; 
-    size_t nargsf; 
- 
-    assert(arg != NULL); 
-    args = _args + 1;  // For PY_VECTORCALL_ARGUMENTS_OFFSET 
-    args[0] = arg; 
-    tstate = PyThreadState_GET(); 
-    nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET; 
-    return _PyObject_VectorcallTstate(tstate, func, args, nargsf, NULL); 
-} 
- 
-PyAPI_FUNC(PyObject *) PyObject_VectorcallMethod( 
-    PyObject *name, PyObject *const *args, 
-    size_t nargsf, PyObject *kwnames); 
- 
-static inline PyObject * 
-PyObject_CallMethodNoArgs(PyObject *self, PyObject *name) 
-{ 
-    return PyObject_VectorcallMethod(name, &self, 
-           1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); 
-} 
- 
-static inline PyObject * 
-PyObject_CallMethodOneArg(PyObject *self, PyObject *name, PyObject *arg) 
-{ 
-    PyObject *args[2] = {self, arg}; 
- 
-    assert(arg != NULL); 
-    return PyObject_VectorcallMethod(name, args, 
-           2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); 
-} 
- 
-/* Like PyObject_CallMethod(), but expect a _Py_Identifier* 
-   as the method name. */ 
-PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj, 
-                                              _Py_Identifier *name, 
-                                              const char *format, ...); 
- 
-PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj, 
-                                                    _Py_Identifier *name, 
-                                                    const char *format, 
-                                                    ...); 
- 
-PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs( 
-    PyObject *obj, 
-    struct _Py_Identifier *name, 
-    ...); 
- 
-static inline PyObject * 
-_PyObject_VectorcallMethodId( 
-    _Py_Identifier *name, PyObject *const *args, 
-    size_t nargsf, PyObject *kwnames) 
-{ 
-    PyObject *oname = _PyUnicode_FromId(name); /* borrowed */ 
-    if (!oname) { 
-        return NULL; 
-    } 
-    return PyObject_VectorcallMethod(oname, args, nargsf, kwnames); 
-} 
- 
-static inline PyObject * 
-_PyObject_CallMethodIdNoArgs(PyObject *self, _Py_Identifier *name) 
-{ 
-    return _PyObject_VectorcallMethodId(name, &self, 
-           1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); 
-} 
- 
-static inline PyObject * 
-_PyObject_CallMethodIdOneArg(PyObject *self, _Py_Identifier *name, PyObject *arg) 
-{ 
-    PyObject *args[2] = {self, arg}; 
- 
-    assert(arg != NULL); 
-    return _PyObject_VectorcallMethodId(name, args, 
-           2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); 
-} 
- 
-PyAPI_FUNC(int) _PyObject_HasLen(PyObject *o); 
- 
-/* Guess the size of object 'o' using len(o) or o.__length_hint__(). 
-   If neither of those return a non-negative value, then return the default 
-   value.  If one of the calls fails, this function returns -1. */ 
-PyAPI_FUNC(Py_ssize_t) PyObject_LengthHint(PyObject *o, Py_ssize_t); 
- 
-/* === New Buffer API ============================================ */ 
- 
-/* Return 1 if the getbuffer function is available, otherwise return 0. */ 
-PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject *obj); 
- 
-/* This is a C-API version of the getbuffer function call.  It checks 
-   to make sure object has the required function pointer and issues the 
-   call. 
- 
-   Returns -1 and raises an error on failure and returns 0 on success. */ 
-PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view, 
-                                   int flags); 
- 
-/* Get the memory area pointed to by the indices for the buffer given. 
-   Note that view->ndim is the assumed size of indices. */ 
-PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices); 
- 
-/* Return the implied itemsize of the data-format area from a 
-   struct-style description. */ 
-PyAPI_FUNC(Py_ssize_t) PyBuffer_SizeFromFormat(const char *format); 
- 
-/* Implementation in memoryobject.c */ 
-PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view, 
-                                      Py_ssize_t len, char order); 
- 
-PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf, 
-                                        Py_ssize_t len, char order); 
- 
-/* Copy len bytes of data from the contiguous chunk of memory 
-   pointed to by buf into the buffer exported by obj.  Return 
-   0 on success and return -1 and raise a PyBuffer_Error on 
-   error (i.e. the object does not have a buffer interface or 
-   it is not working). 
- 
-   If fort is 'F', then if the object is multi-dimensional, 
-   then the data will be copied into the array in 
-   Fortran-style (first dimension varies the fastest).  If 
-   fort is 'C', then the data will be copied into the array 
-   in C-style (last dimension varies the fastest).  If fort 
-   is 'A', then it does not matter and the copy will be made 
-   in whatever way is more efficient. */ 
-PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src); 
- 
-/* Copy the data from the src buffer to the buffer of destination. */ 
-PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort); 
- 
-/*Fill the strides array with byte-strides of a contiguous 
-  (Fortran-style if fort is 'F' or C-style otherwise) 
-  array of the given shape with the given number of bytes 
-  per element. */ 
-PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, 
-                                               Py_ssize_t *shape, 
-                                               Py_ssize_t *strides, 
-                                               int itemsize, 
-                                               char fort); 
- 
-/* Fills in a buffer-info structure correctly for an exporter 
-   that can only share a contiguous chunk of memory of 
-   "unsigned bytes" of the given length. 
- 
-   Returns 0 on success and -1 (with raising an error) on error. */ 
-PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf, 
-                                  Py_ssize_t len, int readonly, 
-                                  int flags); 
- 
-/* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */ 
-PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view); 
- 
-/* ==== Iterators ================================================ */ 
- 
-#define PyIter_Check(obj) \ 
-    (Py_TYPE(obj)->tp_iternext != NULL && \ 
-     Py_TYPE(obj)->tp_iternext != &_PyObject_NextNotImplemented) 
- 
-/* === Sequence protocol ================================================ */ 
- 
-/* Assume tp_as_sequence and sq_item exist and that 'i' does not 
-   need to be corrected for a negative index. */ 
-#define PySequence_ITEM(o, i)\ 
-    ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) ) 
- 
-#define PY_ITERSEARCH_COUNT    1 
-#define PY_ITERSEARCH_INDEX    2 
-#define PY_ITERSEARCH_CONTAINS 3 
- 
-/* Iterate over seq. 
- 
-   Result depends on the operation: 
- 
-   PY_ITERSEARCH_COUNT:  return # of times obj appears in seq; -1 if 
-     error. 
-   PY_ITERSEARCH_INDEX:  return 0-based index of first occurrence of 
-     obj in seq; set ValueError and return -1 if none found; 
-     also return -1 on error. 
-   PY_ITERSEARCH_CONTAINS:  return 1 if obj in seq, else 0; -1 on 
-     error. */ 
-PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq, 
-                                              PyObject *obj, int operation); 
- 
-/* === Mapping protocol ================================================= */ 
- 
-PyAPI_FUNC(int) _PyObject_RealIsInstance(PyObject *inst, PyObject *cls); 
- 
-PyAPI_FUNC(int) _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls); 
- 
-PyAPI_FUNC(char *const *) _PySequence_BytesToCharpArray(PyObject* self); 
- 
-PyAPI_FUNC(void) _Py_FreeCharPArray(char *const array[]); 
- 
-/* For internal use by buffer API functions */ 
-PyAPI_FUNC(void) _Py_add_one_to_index_F(int nd, Py_ssize_t *index, 
-                                        const Py_ssize_t *shape); 
-PyAPI_FUNC(void) _Py_add_one_to_index_C(int nd, Py_ssize_t *index, 
-                                        const Py_ssize_t *shape); 
- 
-/* Convert Python int to Py_ssize_t. Do nothing if the argument is None. */ 
-PyAPI_FUNC(int) _Py_convert_optional_to_ssize_t(PyObject *, void *); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_ABSTRACTOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === Object Protocol ================================================== */
+
+#ifdef PY_SSIZE_T_CLEAN
+#  define _PyObject_CallMethodId _PyObject_CallMethodId_SizeT
+#endif
+
+/* Convert keyword arguments from the FASTCALL (stack: C array, kwnames: tuple)
+   format to a Python dictionary ("kwargs" dict).
+
+   The type of kwnames keys is not checked. The final function getting
+   arguments is responsible to check if all keys are strings, for example using
+   PyArg_ParseTupleAndKeywords() or PyArg_ValidateKeywordArguments().
+
+   Duplicate keys are merged using the last value. If duplicate keys must raise
+   an exception, the caller is responsible to implement an explicit keys on
+   kwnames. */
+PyAPI_FUNC(PyObject *) _PyStack_AsDict(
+    PyObject *const *values,
+    PyObject *kwnames);
+
+/* Suggested size (number of positional arguments) for arrays of PyObject*
+   allocated on a C stack to avoid allocating memory on the heap memory. Such
+   array is used to pass positional arguments to call functions of the
+   PyObject_Vectorcall() family.
+
+   The size is chosen to not abuse the C stack and so limit the risk of stack
+   overflow. The size is also chosen to allow using the small stack for most
+   function calls of the Python standard library. On 64-bit CPU, it allocates
+   40 bytes on the stack. */
+#define _PY_FASTCALL_SMALL_STACK 5
+
+PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult(
+    PyThreadState *tstate,
+    PyObject *callable,
+    PyObject *result,
+    const char *where);
+
+/* === Vectorcall protocol (PEP 590) ============================= */
+
+/* Call callable using tp_call. Arguments are like PyObject_Vectorcall()
+   or PyObject_FastCallDict() (both forms are supported),
+   except that nargs is plainly the number of arguments without flags. */
+PyAPI_FUNC(PyObject *) _PyObject_MakeTpCall(
+    PyThreadState *tstate,
+    PyObject *callable,
+    PyObject *const *args, Py_ssize_t nargs,
+    PyObject *keywords);
+
+#define PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1))
+
+static inline Py_ssize_t
+PyVectorcall_NARGS(size_t n)
+{
+    return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET;
+}
+
+static inline vectorcallfunc
+PyVectorcall_Function(PyObject *callable)
+{
+    PyTypeObject *tp;
+    Py_ssize_t offset;
+    vectorcallfunc ptr;
+
+    assert(callable != NULL);
+    tp = Py_TYPE(callable);
+    if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) {
+        return NULL;
+    }
+    assert(PyCallable_Check(callable));
+    offset = tp->tp_vectorcall_offset;
+    assert(offset > 0);
+    memcpy(&ptr, (char *) callable + offset, sizeof(ptr));
+    return ptr;
+}
+
+/* Call the callable object 'callable' with the "vectorcall" calling
+   convention.
+
+   args is a C array for positional arguments.
+
+   nargsf is the number of positional arguments plus optionally the flag
+   PY_VECTORCALL_ARGUMENTS_OFFSET which means that the caller is allowed to
+   modify args[-1].
+
+   kwnames is a tuple of keyword names. The values of the keyword arguments
+   are stored in "args" after the positional arguments (note that the number
+   of keyword arguments does not change nargsf). kwnames can also be NULL if
+   there are no keyword arguments.
+
+   keywords must only contain strings and all keys must be unique.
+
+   Return the result on success. Raise an exception and return NULL on
+   error. */
+static inline PyObject *
+_PyObject_VectorcallTstate(PyThreadState *tstate, PyObject *callable,
+                           PyObject *const *args, size_t nargsf,
+                           PyObject *kwnames)
+{
+    vectorcallfunc func;
+    PyObject *res;
+
+    assert(kwnames == NULL || PyTuple_Check(kwnames));
+    assert(args != NULL || PyVectorcall_NARGS(nargsf) == 0);
+
+    func = PyVectorcall_Function(callable);
+    if (func == NULL) {
+        Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+        return _PyObject_MakeTpCall(tstate, callable, args, nargs, kwnames);
+    }
+    res = func(callable, args, nargsf, kwnames);
+    return _Py_CheckFunctionResult(tstate, callable, res, NULL);
+}
+
+static inline PyObject *
+PyObject_Vectorcall(PyObject *callable, PyObject *const *args,
+                     size_t nargsf, PyObject *kwnames)
+{
+    PyThreadState *tstate = PyThreadState_GET();
+    return _PyObject_VectorcallTstate(tstate, callable,
+                                      args, nargsf, kwnames);
+}
+
+// Backwards compatibility aliases for API that was provisional in Python 3.8
+#define _PyObject_Vectorcall PyObject_Vectorcall
+#define _PyObject_VectorcallMethod PyObject_VectorcallMethod
+#define _PyObject_FastCallDict PyObject_VectorcallDict
+#define _PyVectorcall_Function PyVectorcall_Function
+#define _PyObject_CallOneArg PyObject_CallOneArg
+#define _PyObject_CallMethodNoArgs PyObject_CallMethodNoArgs
+#define _PyObject_CallMethodOneArg PyObject_CallMethodOneArg
+
+/* Same as PyObject_Vectorcall except that keyword arguments are passed as
+   dict, which may be NULL if there are no keyword arguments. */
+PyAPI_FUNC(PyObject *) PyObject_VectorcallDict(
+    PyObject *callable,
+    PyObject *const *args,
+    size_t nargsf,
+    PyObject *kwargs);
+
+/* Call "callable" (which must support vectorcall) with positional arguments
+   "tuple" and keyword arguments "dict". "dict" may also be NULL */
+PyAPI_FUNC(PyObject *) PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *dict);
+
+static inline PyObject *
+_PyObject_FastCallTstate(PyThreadState *tstate, PyObject *func, PyObject *const *args, Py_ssize_t nargs)
+{
+    return _PyObject_VectorcallTstate(tstate, func, args, (size_t)nargs, NULL);
+}
+
+/* Same as PyObject_Vectorcall except without keyword arguments */
+static inline PyObject *
+_PyObject_FastCall(PyObject *func, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyThreadState *tstate = PyThreadState_GET();
+    return _PyObject_FastCallTstate(tstate, func, args, nargs);
+}
+
+/* Call a callable without any arguments
+   Private static inline function variant of public function
+   PyObject_CallNoArgs(). */
+static inline PyObject *
+_PyObject_CallNoArg(PyObject *func) {
+    PyThreadState *tstate = PyThreadState_GET();
+    return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL);
+}
+
+static inline PyObject *
+PyObject_CallOneArg(PyObject *func, PyObject *arg)
+{
+    PyObject *_args[2];
+    PyObject **args;
+    PyThreadState *tstate;
+    size_t nargsf;
+
+    assert(arg != NULL);
+    args = _args + 1;  // For PY_VECTORCALL_ARGUMENTS_OFFSET
+    args[0] = arg;
+    tstate = PyThreadState_GET();
+    nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;
+    return _PyObject_VectorcallTstate(tstate, func, args, nargsf, NULL);
+}
+
+PyAPI_FUNC(PyObject *) PyObject_VectorcallMethod(
+    PyObject *name, PyObject *const *args,
+    size_t nargsf, PyObject *kwnames);
+
+static inline PyObject *
+PyObject_CallMethodNoArgs(PyObject *self, PyObject *name)
+{
+    return PyObject_VectorcallMethod(name, &self,
+           1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+}
+
+static inline PyObject *
+PyObject_CallMethodOneArg(PyObject *self, PyObject *name, PyObject *arg)
+{
+    PyObject *args[2] = {self, arg};
+
+    assert(arg != NULL);
+    return PyObject_VectorcallMethod(name, args,
+           2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+}
+
+/* Like PyObject_CallMethod(), but expect a _Py_Identifier*
+   as the method name. */
+PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj,
+                                              _Py_Identifier *name,
+                                              const char *format, ...);
+
+PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj,
+                                                    _Py_Identifier *name,
+                                                    const char *format,
+                                                    ...);
+
+PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs(
+    PyObject *obj,
+    struct _Py_Identifier *name,
+    ...);
+
+static inline PyObject *
+_PyObject_VectorcallMethodId(
+    _Py_Identifier *name, PyObject *const *args,
+    size_t nargsf, PyObject *kwnames)
+{
+    PyObject *oname = _PyUnicode_FromId(name); /* borrowed */
+    if (!oname) {
+        return NULL;
+    }
+    return PyObject_VectorcallMethod(oname, args, nargsf, kwnames);
+}
+
+static inline PyObject *
+_PyObject_CallMethodIdNoArgs(PyObject *self, _Py_Identifier *name)
+{
+    return _PyObject_VectorcallMethodId(name, &self,
+           1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+}
+
+static inline PyObject *
+_PyObject_CallMethodIdOneArg(PyObject *self, _Py_Identifier *name, PyObject *arg)
+{
+    PyObject *args[2] = {self, arg};
+
+    assert(arg != NULL);
+    return _PyObject_VectorcallMethodId(name, args,
+           2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+}
+
+PyAPI_FUNC(int) _PyObject_HasLen(PyObject *o);
+
+/* Guess the size of object 'o' using len(o) or o.__length_hint__().
+   If neither of those return a non-negative value, then return the default
+   value.  If one of the calls fails, this function returns -1. */
+PyAPI_FUNC(Py_ssize_t) PyObject_LengthHint(PyObject *o, Py_ssize_t);
+
+/* === New Buffer API ============================================ */
+
+/* Return 1 if the getbuffer function is available, otherwise return 0. */
+PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject *obj);
+
+/* This is a C-API version of the getbuffer function call.  It checks
+   to make sure object has the required function pointer and issues the
+   call.
+
+   Returns -1 and raises an error on failure and returns 0 on success. */
+PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
+                                   int flags);
+
+/* Get the memory area pointed to by the indices for the buffer given.
+   Note that view->ndim is the assumed size of indices. */
+PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);
+
+/* Return the implied itemsize of the data-format area from a
+   struct-style description. */
+PyAPI_FUNC(Py_ssize_t) PyBuffer_SizeFromFormat(const char *format);
+
+/* Implementation in memoryobject.c */
+PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view,
+                                      Py_ssize_t len, char order);
+
+PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf,
+                                        Py_ssize_t len, char order);
+
+/* Copy len bytes of data from the contiguous chunk of memory
+   pointed to by buf into the buffer exported by obj.  Return
+   0 on success and return -1 and raise a PyBuffer_Error on
+   error (i.e. the object does not have a buffer interface or
+   it is not working).
+
+   If fort is 'F', then if the object is multi-dimensional,
+   then the data will be copied into the array in
+   Fortran-style (first dimension varies the fastest).  If
+   fort is 'C', then the data will be copied into the array
+   in C-style (last dimension varies the fastest).  If fort
+   is 'A', then it does not matter and the copy will be made
+   in whatever way is more efficient. */
+PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src);
+
+/* Copy the data from the src buffer to the buffer of destination. */
+PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort);
+
+/*Fill the strides array with byte-strides of a contiguous
+  (Fortran-style if fort is 'F' or C-style otherwise)
+  array of the given shape with the given number of bytes
+  per element. */
+PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims,
+                                               Py_ssize_t *shape,
+                                               Py_ssize_t *strides,
+                                               int itemsize,
+                                               char fort);
+
+/* Fills in a buffer-info structure correctly for an exporter
+   that can only share a contiguous chunk of memory of
+   "unsigned bytes" of the given length.
+
+   Returns 0 on success and -1 (with raising an error) on error. */
+PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf,
+                                  Py_ssize_t len, int readonly,
+                                  int flags);
+
+/* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */
+PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view);
+
+/* ==== Iterators ================================================ */
+
+#define PyIter_Check(obj) \
+    (Py_TYPE(obj)->tp_iternext != NULL && \
+     Py_TYPE(obj)->tp_iternext != &_PyObject_NextNotImplemented)
+
+/* === Sequence protocol ================================================ */
+
+/* Assume tp_as_sequence and sq_item exist and that 'i' does not
+   need to be corrected for a negative index. */
+#define PySequence_ITEM(o, i)\
+    ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) )
+
+#define PY_ITERSEARCH_COUNT    1
+#define PY_ITERSEARCH_INDEX    2
+#define PY_ITERSEARCH_CONTAINS 3
+
+/* Iterate over seq.
+
+   Result depends on the operation:
+
+   PY_ITERSEARCH_COUNT:  return # of times obj appears in seq; -1 if
+     error.
+   PY_ITERSEARCH_INDEX:  return 0-based index of first occurrence of
+     obj in seq; set ValueError and return -1 if none found;
+     also return -1 on error.
+   PY_ITERSEARCH_CONTAINS:  return 1 if obj in seq, else 0; -1 on
+     error. */
+PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq,
+                                              PyObject *obj, int operation);
+
+/* === Mapping protocol ================================================= */
+
+PyAPI_FUNC(int) _PyObject_RealIsInstance(PyObject *inst, PyObject *cls);
+
+PyAPI_FUNC(int) _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls);
+
+PyAPI_FUNC(char *const *) _PySequence_BytesToCharpArray(PyObject* self);
+
+PyAPI_FUNC(void) _Py_FreeCharPArray(char *const array[]);
+
+/* For internal use by buffer API functions */
+PyAPI_FUNC(void) _Py_add_one_to_index_F(int nd, Py_ssize_t *index,
+                                        const Py_ssize_t *shape);
+PyAPI_FUNC(void) _Py_add_one_to_index_C(int nd, Py_ssize_t *index,
+                                        const Py_ssize_t *shape);
+
+/* Convert Python int to Py_ssize_t. Do nothing if the argument is None. */
+PyAPI_FUNC(int) _Py_convert_optional_to_ssize_t(PyObject *, void *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/bytearrayobject.h b/contrib/tools/python3/src/Include/cpython/bytearrayobject.h
index 4969d5f807..569b0cd036 100644
--- a/contrib/tools/python3/src/Include/cpython/bytearrayobject.h
+++ b/contrib/tools/python3/src/Include/cpython/bytearrayobject.h
@@ -1,20 +1,20 @@
-#ifndef Py_CPYTHON_BYTEARRAYOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-/* Object layout */ 
-typedef struct { 
-    PyObject_VAR_HEAD 
-    Py_ssize_t ob_alloc;   /* How many bytes allocated in ob_bytes */ 
-    char *ob_bytes;        /* Physical backing buffer */ 
-    char *ob_start;        /* Logical start inside ob_bytes */ 
-    Py_ssize_t ob_exports; /* How many buffer exports */ 
-} PyByteArrayObject; 
- 
-/* Macros, trading safety for speed */ 
-#define PyByteArray_AS_STRING(self) \ 
-    (assert(PyByteArray_Check(self)), \ 
-     Py_SIZE(self) ? ((PyByteArrayObject *)(self))->ob_start : _PyByteArray_empty_string) 
-#define PyByteArray_GET_SIZE(self) (assert(PyByteArray_Check(self)), Py_SIZE(self)) 
- 
-PyAPI_DATA(char) _PyByteArray_empty_string[]; 
+#ifndef Py_CPYTHON_BYTEARRAYOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+/* Object layout */
+typedef struct {
+    PyObject_VAR_HEAD
+    Py_ssize_t ob_alloc;   /* How many bytes allocated in ob_bytes */
+    char *ob_bytes;        /* Physical backing buffer */
+    char *ob_start;        /* Logical start inside ob_bytes */
+    Py_ssize_t ob_exports; /* How many buffer exports */
+} PyByteArrayObject;
+
+/* Macros, trading safety for speed */
+#define PyByteArray_AS_STRING(self) \
+    (assert(PyByteArray_Check(self)), \
+     Py_SIZE(self) ? ((PyByteArrayObject *)(self))->ob_start : _PyByteArray_empty_string)
+#define PyByteArray_GET_SIZE(self) (assert(PyByteArray_Check(self)), Py_SIZE(self))
+
+PyAPI_DATA(char) _PyByteArray_empty_string[];
diff --git a/contrib/tools/python3/src/Include/cpython/bytesobject.h b/contrib/tools/python3/src/Include/cpython/bytesobject.h
index 6eb7eb8f25..f284c5835d 100644
--- a/contrib/tools/python3/src/Include/cpython/bytesobject.h
+++ b/contrib/tools/python3/src/Include/cpython/bytesobject.h
@@ -1,118 +1,118 @@
-#ifndef Py_CPYTHON_BYTESOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-typedef struct { 
-    PyObject_VAR_HEAD 
-    Py_hash_t ob_shash; 
-    char ob_sval[1]; 
- 
-    /* Invariants: 
-     *     ob_sval contains space for 'ob_size+1' elements. 
-     *     ob_sval[ob_size] == 0. 
-     *     ob_shash is the hash of the string or -1 if not computed yet. 
-     */ 
-} PyBytesObject; 
- 
-PyAPI_FUNC(int) _PyBytes_Resize(PyObject **, Py_ssize_t); 
-PyAPI_FUNC(PyObject*) _PyBytes_FormatEx( 
-    const char *format, 
-    Py_ssize_t format_len, 
-    PyObject *args, 
-    int use_bytearray); 
-PyAPI_FUNC(PyObject*) _PyBytes_FromHex( 
-    PyObject *string, 
-    int use_bytearray); 
- 
-/* Helper for PyBytes_DecodeEscape that detects invalid escape chars. */ 
-PyAPI_FUNC(PyObject *) _PyBytes_DecodeEscape(const char *, Py_ssize_t, 
-                                             const char *, const char **); 
- 
-/* Macro, trading safety for speed */ 
-#define PyBytes_AS_STRING(op) (assert(PyBytes_Check(op)), \ 
-                                (((PyBytesObject *)(op))->ob_sval)) 
-#define PyBytes_GET_SIZE(op)  (assert(PyBytes_Check(op)),Py_SIZE(op)) 
- 
-/* _PyBytes_Join(sep, x) is like sep.join(x).  sep must be PyBytesObject*, 
-   x must be an iterable object. */ 
-PyAPI_FUNC(PyObject *) _PyBytes_Join(PyObject *sep, PyObject *x); 
- 
- 
-/* The _PyBytesWriter structure is big: it contains an embedded "stack buffer". 
-   A _PyBytesWriter variable must be declared at the end of variables in a 
-   function to optimize the memory allocation on the stack. */ 
-typedef struct { 
-    /* bytes, bytearray or NULL (when the small buffer is used) */ 
-    PyObject *buffer; 
- 
-    /* Number of allocated size. */ 
-    Py_ssize_t allocated; 
- 
-    /* Minimum number of allocated bytes, 
-       incremented by _PyBytesWriter_Prepare() */ 
-    Py_ssize_t min_size; 
- 
-    /* If non-zero, use a bytearray instead of a bytes object for buffer. */ 
-    int use_bytearray; 
- 
-    /* If non-zero, overallocate the buffer (default: 0). 
-       This flag must be zero if use_bytearray is non-zero. */ 
-    int overallocate; 
- 
-    /* Stack buffer */ 
-    int use_small_buffer; 
-    char small_buffer[512]; 
-} _PyBytesWriter; 
- 
-/* Initialize a bytes writer 
- 
-   By default, the overallocation is disabled. Set the overallocate attribute 
-   to control the allocation of the buffer. */ 
-PyAPI_FUNC(void) _PyBytesWriter_Init(_PyBytesWriter *writer); 
- 
-/* Get the buffer content and reset the writer. 
-   Return a bytes object, or a bytearray object if use_bytearray is non-zero. 
-   Raise an exception and return NULL on error. */ 
-PyAPI_FUNC(PyObject *) _PyBytesWriter_Finish(_PyBytesWriter *writer, 
-    void *str); 
- 
-/* Deallocate memory of a writer (clear its internal buffer). */ 
-PyAPI_FUNC(void) _PyBytesWriter_Dealloc(_PyBytesWriter *writer); 
- 
-/* Allocate the buffer to write size bytes. 
-   Return the pointer to the beginning of buffer data. 
-   Raise an exception and return NULL on error. */ 
-PyAPI_FUNC(void*) _PyBytesWriter_Alloc(_PyBytesWriter *writer, 
-    Py_ssize_t size); 
- 
-/* Ensure that the buffer is large enough to write *size* bytes. 
-   Add size to the writer minimum size (min_size attribute). 
- 
-   str is the current pointer inside the buffer. 
-   Return the updated current pointer inside the buffer. 
-   Raise an exception and return NULL on error. */ 
-PyAPI_FUNC(void*) _PyBytesWriter_Prepare(_PyBytesWriter *writer, 
-    void *str, 
-    Py_ssize_t size); 
- 
-/* Resize the buffer to make it larger. 
-   The new buffer may be larger than size bytes because of overallocation. 
-   Return the updated current pointer inside the buffer. 
-   Raise an exception and return NULL on error. 
- 
-   Note: size must be greater than the number of allocated bytes in the writer. 
- 
-   This function doesn't use the writer minimum size (min_size attribute). 
- 
-   See also _PyBytesWriter_Prepare(). 
-   */ 
-PyAPI_FUNC(void*) _PyBytesWriter_Resize(_PyBytesWriter *writer, 
-    void *str, 
-    Py_ssize_t size); 
- 
-/* Write bytes. 
-   Raise an exception and return NULL on error. */ 
-PyAPI_FUNC(void*) _PyBytesWriter_WriteBytes(_PyBytesWriter *writer, 
-    void *str, 
-    const void *bytes, 
-    Py_ssize_t size); 
+#ifndef Py_CPYTHON_BYTESOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+typedef struct {
+    PyObject_VAR_HEAD
+    Py_hash_t ob_shash;
+    char ob_sval[1];
+
+    /* Invariants:
+     *     ob_sval contains space for 'ob_size+1' elements.
+     *     ob_sval[ob_size] == 0.
+     *     ob_shash is the hash of the string or -1 if not computed yet.
+     */
+} PyBytesObject;
+
+PyAPI_FUNC(int) _PyBytes_Resize(PyObject **, Py_ssize_t);
+PyAPI_FUNC(PyObject*) _PyBytes_FormatEx(
+    const char *format,
+    Py_ssize_t format_len,
+    PyObject *args,
+    int use_bytearray);
+PyAPI_FUNC(PyObject*) _PyBytes_FromHex(
+    PyObject *string,
+    int use_bytearray);
+
+/* Helper for PyBytes_DecodeEscape that detects invalid escape chars. */
+PyAPI_FUNC(PyObject *) _PyBytes_DecodeEscape(const char *, Py_ssize_t,
+                                             const char *, const char **);
+
+/* Macro, trading safety for speed */
+#define PyBytes_AS_STRING(op) (assert(PyBytes_Check(op)), \
+                                (((PyBytesObject *)(op))->ob_sval))
+#define PyBytes_GET_SIZE(op)  (assert(PyBytes_Check(op)),Py_SIZE(op))
+
+/* _PyBytes_Join(sep, x) is like sep.join(x).  sep must be PyBytesObject*,
+   x must be an iterable object. */
+PyAPI_FUNC(PyObject *) _PyBytes_Join(PyObject *sep, PyObject *x);
+
+
+/* The _PyBytesWriter structure is big: it contains an embedded "stack buffer".
+   A _PyBytesWriter variable must be declared at the end of variables in a
+   function to optimize the memory allocation on the stack. */
+typedef struct {
+    /* bytes, bytearray or NULL (when the small buffer is used) */
+    PyObject *buffer;
+
+    /* Number of allocated size. */
+    Py_ssize_t allocated;
+
+    /* Minimum number of allocated bytes,
+       incremented by _PyBytesWriter_Prepare() */
+    Py_ssize_t min_size;
+
+    /* If non-zero, use a bytearray instead of a bytes object for buffer. */
+    int use_bytearray;
+
+    /* If non-zero, overallocate the buffer (default: 0).
+       This flag must be zero if use_bytearray is non-zero. */
+    int overallocate;
+
+    /* Stack buffer */
+    int use_small_buffer;
+    char small_buffer[512];
+} _PyBytesWriter;
+
+/* Initialize a bytes writer
+
+   By default, the overallocation is disabled. Set the overallocate attribute
+   to control the allocation of the buffer. */
+PyAPI_FUNC(void) _PyBytesWriter_Init(_PyBytesWriter *writer);
+
+/* Get the buffer content and reset the writer.
+   Return a bytes object, or a bytearray object if use_bytearray is non-zero.
+   Raise an exception and return NULL on error. */
+PyAPI_FUNC(PyObject *) _PyBytesWriter_Finish(_PyBytesWriter *writer,
+    void *str);
+
+/* Deallocate memory of a writer (clear its internal buffer). */
+PyAPI_FUNC(void) _PyBytesWriter_Dealloc(_PyBytesWriter *writer);
+
+/* Allocate the buffer to write size bytes.
+   Return the pointer to the beginning of buffer data.
+   Raise an exception and return NULL on error. */
+PyAPI_FUNC(void*) _PyBytesWriter_Alloc(_PyBytesWriter *writer,
+    Py_ssize_t size);
+
+/* Ensure that the buffer is large enough to write *size* bytes.
+   Add size to the writer minimum size (min_size attribute).
+
+   str is the current pointer inside the buffer.
+   Return the updated current pointer inside the buffer.
+   Raise an exception and return NULL on error. */
+PyAPI_FUNC(void*) _PyBytesWriter_Prepare(_PyBytesWriter *writer,
+    void *str,
+    Py_ssize_t size);
+
+/* Resize the buffer to make it larger.
+   The new buffer may be larger than size bytes because of overallocation.
+   Return the updated current pointer inside the buffer.
+   Raise an exception and return NULL on error.
+
+   Note: size must be greater than the number of allocated bytes in the writer.
+
+   This function doesn't use the writer minimum size (min_size attribute).
+
+   See also _PyBytesWriter_Prepare().
+   */
+PyAPI_FUNC(void*) _PyBytesWriter_Resize(_PyBytesWriter *writer,
+    void *str,
+    Py_ssize_t size);
+
+/* Write bytes.
+   Raise an exception and return NULL on error. */
+PyAPI_FUNC(void*) _PyBytesWriter_WriteBytes(_PyBytesWriter *writer,
+    void *str,
+    const void *bytes,
+    Py_ssize_t size);
diff --git a/contrib/tools/python3/src/Include/cpython/ceval.h b/contrib/tools/python3/src/Include/cpython/ceval.h
index 6b37af7f59..e1922a677b 100644
--- a/contrib/tools/python3/src/Include/cpython/ceval.h
+++ b/contrib/tools/python3/src/Include/cpython/ceval.h
@@ -1,38 +1,38 @@
-#ifndef Py_CPYTHON_CEVAL_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *); 
-PyAPI_DATA(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); 
-PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *); 
-PyAPI_FUNC(int) _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); 
-PyAPI_FUNC(int) _PyEval_GetCoroutineOriginTrackingDepth(void); 
-PyAPI_FUNC(int) _PyEval_SetAsyncGenFirstiter(PyObject *); 
-PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFirstiter(void); 
-PyAPI_FUNC(int) _PyEval_SetAsyncGenFinalizer(PyObject *); 
-PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFinalizer(void); 
- 
-/* Helper to look up a builtin object */ 
-PyAPI_FUNC(PyObject *) _PyEval_GetBuiltinId(_Py_Identifier *); 
-/* Look at the current frame's (if any) code's co_flags, and turn on 
-   the corresponding compiler flags in cf->cf_flags.  Return 1 if any 
-   flag was set, else return 0. */ 
-PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf); 
- 
-PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int exc); 
- 
-PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds); 
-PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void); 
- 
-PyAPI_FUNC(Py_ssize_t) _PyEval_RequestCodeExtraIndex(freefunc); 
- 
-PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *); 
-PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_CEVAL_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *);
+PyAPI_DATA(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg);
+PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *);
+PyAPI_FUNC(int) _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg);
+PyAPI_FUNC(int) _PyEval_GetCoroutineOriginTrackingDepth(void);
+PyAPI_FUNC(int) _PyEval_SetAsyncGenFirstiter(PyObject *);
+PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFirstiter(void);
+PyAPI_FUNC(int) _PyEval_SetAsyncGenFinalizer(PyObject *);
+PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFinalizer(void);
+
+/* Helper to look up a builtin object */
+PyAPI_FUNC(PyObject *) _PyEval_GetBuiltinId(_Py_Identifier *);
+/* Look at the current frame's (if any) code's co_flags, and turn on
+   the corresponding compiler flags in cf->cf_flags.  Return 1 if any
+   flag was set, else return 0. */
+PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
+
+PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int exc);
+
+PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds);
+PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void);
+
+PyAPI_FUNC(Py_ssize_t) _PyEval_RequestCodeExtraIndex(freefunc);
+
+PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/code.h b/contrib/tools/python3/src/Include/cpython/code.h
index 93e532e6ec..cda28ac6ee 100644
--- a/contrib/tools/python3/src/Include/cpython/code.h
+++ b/contrib/tools/python3/src/Include/cpython/code.h
@@ -1,165 +1,165 @@
-#ifndef Py_CPYTHON_CODE_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-typedef uint16_t _Py_CODEUNIT; 
- 
-#ifdef WORDS_BIGENDIAN 
-#  define _Py_OPCODE(word) ((word) >> 8) 
-#  define _Py_OPARG(word) ((word) & 255) 
-#else 
-#  define _Py_OPCODE(word) ((word) & 255) 
-#  define _Py_OPARG(word) ((word) >> 8) 
-#endif 
- 
-typedef struct _PyOpcache _PyOpcache; 
- 
-/* Bytecode object */ 
-struct PyCodeObject { 
-    PyObject_HEAD 
-    int co_argcount;            /* #arguments, except *args */ 
-    int co_posonlyargcount;     /* #positional only arguments */ 
-    int co_kwonlyargcount;      /* #keyword only arguments */ 
-    int co_nlocals;             /* #local variables */ 
-    int co_stacksize;           /* #entries needed for evaluation stack */ 
-    int co_flags;               /* CO_..., see below */ 
-    int co_firstlineno;         /* first source line number */ 
-    PyObject *co_code;          /* instruction opcodes */ 
-    PyObject *co_consts;        /* list (constants used) */ 
-    PyObject *co_names;         /* list of strings (names used) */ 
-    PyObject *co_varnames;      /* tuple of strings (local variable names) */ 
-    PyObject *co_freevars;      /* tuple of strings (free variable names) */ 
-    PyObject *co_cellvars;      /* tuple of strings (cell variable names) */ 
-    /* The rest aren't used in either hash or comparisons, except for co_name, 
-       used in both. This is done to preserve the name and line number 
-       for tracebacks and debuggers; otherwise, constant de-duplication 
-       would collapse identical functions/lambdas defined on different lines. 
-    */ 
-    Py_ssize_t *co_cell2arg;    /* Maps cell vars which are arguments. */ 
-    PyObject *co_filename;      /* unicode (where it was loaded from) */ 
-    PyObject *co_name;          /* unicode (name, for reference) */ 
-    PyObject *co_lnotab;        /* string (encoding addr<->lineno mapping) See 
-                                   Objects/lnotab_notes.txt for details. */ 
-    void *co_zombieframe;       /* for optimization only (see frameobject.c) */ 
-    PyObject *co_weakreflist;   /* to support weakrefs to code objects */ 
-    /* Scratch space for extra data relating to the code object. 
-       Type is a void* to keep the format private in codeobject.c to force 
-       people to go through the proper APIs. */ 
-    void *co_extra; 
- 
-    /* Per opcodes just-in-time cache 
-     * 
-     * To reduce cache size, we use indirect mapping from opcode index to 
-     * cache object: 
-     *   cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1] 
-     */ 
- 
-    // co_opcache_map is indexed by (next_instr - first_instr). 
-    //  * 0 means there is no cache for this opcode. 
-    //  * n > 0 means there is cache in co_opcache[n-1]. 
-    unsigned char *co_opcache_map; 
-    _PyOpcache *co_opcache; 
-    int co_opcache_flag;  // used to determine when create a cache. 
-    unsigned char co_opcache_size;  // length of co_opcache. 
-}; 
- 
-/* Masks for co_flags above */ 
-#define CO_OPTIMIZED    0x0001 
-#define CO_NEWLOCALS    0x0002 
-#define CO_VARARGS      0x0004 
-#define CO_VARKEYWORDS  0x0008 
-#define CO_NESTED       0x0010 
-#define CO_GENERATOR    0x0020 
-/* The CO_NOFREE flag is set if there are no free or cell variables. 
-   This information is redundant, but it allows a single flag test 
-   to determine whether there is any extra work to be done when the 
-   call frame it setup. 
-*/ 
-#define CO_NOFREE       0x0040 
- 
-/* The CO_COROUTINE flag is set for coroutine functions (defined with 
-   ``async def`` keywords) */ 
-#define CO_COROUTINE            0x0080 
-#define CO_ITERABLE_COROUTINE   0x0100 
-#define CO_ASYNC_GENERATOR      0x0200 
- 
-/* bpo-39562: These constant values are changed in Python 3.9 
-   to prevent collision with compiler flags. CO_FUTURE_ and PyCF_ 
-   constants must be kept unique. PyCF_ constants can use bits from 
-   0x0100 to 0x10000. CO_FUTURE_ constants use bits starting at 0x20000. */ 
-#define CO_FUTURE_DIVISION      0x20000 
-#define CO_FUTURE_ABSOLUTE_IMPORT 0x40000 /* do absolute imports by default */ 
-#define CO_FUTURE_WITH_STATEMENT  0x80000 
-#define CO_FUTURE_PRINT_FUNCTION  0x100000 
-#define CO_FUTURE_UNICODE_LITERALS 0x200000 
- 
-#define CO_FUTURE_BARRY_AS_BDFL  0x400000 
-#define CO_FUTURE_GENERATOR_STOP  0x800000 
-#define CO_FUTURE_ANNOTATIONS    0x1000000 
- 
-/* This value is found in the co_cell2arg array when the associated cell 
-   variable does not correspond to an argument. */ 
-#define CO_CELL_NOT_AN_ARG (-1) 
- 
-/* This should be defined if a future statement modifies the syntax. 
-   For example, when a keyword is added. 
-*/ 
-#define PY_PARSER_REQUIRES_FUTURE_KEYWORD 
- 
-#define CO_MAXBLOCKS 20 /* Max static block nesting within a function */ 
- 
-PyAPI_DATA(PyTypeObject) PyCode_Type; 
- 
-#define PyCode_Check(op) Py_IS_TYPE(op, &PyCode_Type) 
-#define PyCode_GetNumFree(op) (PyTuple_GET_SIZE((op)->co_freevars)) 
- 
-/* Public interface */ 
-PyAPI_FUNC(PyCodeObject *) PyCode_New( 
-        int, int, int, int, int, PyObject *, PyObject *, 
-        PyObject *, PyObject *, PyObject *, PyObject *, 
-        PyObject *, PyObject *, int, PyObject *); 
- 
-PyAPI_FUNC(PyCodeObject *) PyCode_NewWithPosOnlyArgs( 
-        int, int, int, int, int, int, PyObject *, PyObject *, 
-        PyObject *, PyObject *, PyObject *, PyObject *, 
-        PyObject *, PyObject *, int, PyObject *); 
-        /* same as struct above */ 
- 
-/* Creates a new empty code object with the specified source location. */ 
-PyAPI_FUNC(PyCodeObject *) 
-PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno); 
- 
-/* Return the line number associated with the specified bytecode index 
-   in this code object.  If you just need the line number of a frame, 
-   use PyFrame_GetLineNumber() instead. */ 
-PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int); 
- 
-/* for internal use only */ 
-typedef struct _addr_pair { 
-        int ap_lower; 
-        int ap_upper; 
-} PyAddrPair; 
- 
-/* Update *bounds to describe the first and one-past-the-last instructions in the 
-   same line as lasti.  Return the number of that line. 
-*/ 
-PyAPI_FUNC(int) _PyCode_CheckLineNumber(PyCodeObject* co, 
-                                        int lasti, PyAddrPair *bounds); 
- 
-/* Create a comparable key used to compare constants taking in account the 
- * object type. It is used to make sure types are not coerced (e.g., float and 
- * complex) _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms 
- * 
- * Return (type(obj), obj, ...): a tuple with variable size (at least 2 items) 
- * depending on the type and the value. The type is the first item to not 
- * compare bytes and str which can raise a BytesWarning exception. */ 
-PyAPI_FUNC(PyObject*) _PyCode_ConstantKey(PyObject *obj); 
- 
-PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts, 
-                                      PyObject *names, PyObject *lnotab); 
- 
- 
-PyAPI_FUNC(int) _PyCode_GetExtra(PyObject *code, Py_ssize_t index, 
-                                 void **extra); 
-PyAPI_FUNC(int) _PyCode_SetExtra(PyObject *code, Py_ssize_t index, 
-                                 void *extra); 
+#ifndef Py_CPYTHON_CODE_H
+#  error "this header file must not be included directly"
+#endif
+
+typedef uint16_t _Py_CODEUNIT;
+
+#ifdef WORDS_BIGENDIAN
+#  define _Py_OPCODE(word) ((word) >> 8)
+#  define _Py_OPARG(word) ((word) & 255)
+#else
+#  define _Py_OPCODE(word) ((word) & 255)
+#  define _Py_OPARG(word) ((word) >> 8)
+#endif
+
+typedef struct _PyOpcache _PyOpcache;
+
+/* Bytecode object */
+struct PyCodeObject {
+    PyObject_HEAD
+    int co_argcount;            /* #arguments, except *args */
+    int co_posonlyargcount;     /* #positional only arguments */
+    int co_kwonlyargcount;      /* #keyword only arguments */
+    int co_nlocals;             /* #local variables */
+    int co_stacksize;           /* #entries needed for evaluation stack */
+    int co_flags;               /* CO_..., see below */
+    int co_firstlineno;         /* first source line number */
+    PyObject *co_code;          /* instruction opcodes */
+    PyObject *co_consts;        /* list (constants used) */
+    PyObject *co_names;         /* list of strings (names used) */
+    PyObject *co_varnames;      /* tuple of strings (local variable names) */
+    PyObject *co_freevars;      /* tuple of strings (free variable names) */
+    PyObject *co_cellvars;      /* tuple of strings (cell variable names) */
+    /* The rest aren't used in either hash or comparisons, except for co_name,
+       used in both. This is done to preserve the name and line number
+       for tracebacks and debuggers; otherwise, constant de-duplication
+       would collapse identical functions/lambdas defined on different lines.
+    */
+    Py_ssize_t *co_cell2arg;    /* Maps cell vars which are arguments. */
+    PyObject *co_filename;      /* unicode (where it was loaded from) */
+    PyObject *co_name;          /* unicode (name, for reference) */
+    PyObject *co_lnotab;        /* string (encoding addr<->lineno mapping) See
+                                   Objects/lnotab_notes.txt for details. */
+    void *co_zombieframe;       /* for optimization only (see frameobject.c) */
+    PyObject *co_weakreflist;   /* to support weakrefs to code objects */
+    /* Scratch space for extra data relating to the code object.
+       Type is a void* to keep the format private in codeobject.c to force
+       people to go through the proper APIs. */
+    void *co_extra;
+
+    /* Per opcodes just-in-time cache
+     *
+     * To reduce cache size, we use indirect mapping from opcode index to
+     * cache object:
+     *   cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
+     */
+
+    // co_opcache_map is indexed by (next_instr - first_instr).
+    //  * 0 means there is no cache for this opcode.
+    //  * n > 0 means there is cache in co_opcache[n-1].
+    unsigned char *co_opcache_map;
+    _PyOpcache *co_opcache;
+    int co_opcache_flag;  // used to determine when create a cache.
+    unsigned char co_opcache_size;  // length of co_opcache.
+};
+
+/* Masks for co_flags above */
+#define CO_OPTIMIZED    0x0001
+#define CO_NEWLOCALS    0x0002
+#define CO_VARARGS      0x0004
+#define CO_VARKEYWORDS  0x0008
+#define CO_NESTED       0x0010
+#define CO_GENERATOR    0x0020
+/* The CO_NOFREE flag is set if there are no free or cell variables.
+   This information is redundant, but it allows a single flag test
+   to determine whether there is any extra work to be done when the
+   call frame it setup.
+*/
+#define CO_NOFREE       0x0040
+
+/* The CO_COROUTINE flag is set for coroutine functions (defined with
+   ``async def`` keywords) */
+#define CO_COROUTINE            0x0080
+#define CO_ITERABLE_COROUTINE   0x0100
+#define CO_ASYNC_GENERATOR      0x0200
+
+/* bpo-39562: These constant values are changed in Python 3.9
+   to prevent collision with compiler flags. CO_FUTURE_ and PyCF_
+   constants must be kept unique. PyCF_ constants can use bits from
+   0x0100 to 0x10000. CO_FUTURE_ constants use bits starting at 0x20000. */
+#define CO_FUTURE_DIVISION      0x20000
+#define CO_FUTURE_ABSOLUTE_IMPORT 0x40000 /* do absolute imports by default */
+#define CO_FUTURE_WITH_STATEMENT  0x80000
+#define CO_FUTURE_PRINT_FUNCTION  0x100000
+#define CO_FUTURE_UNICODE_LITERALS 0x200000
+
+#define CO_FUTURE_BARRY_AS_BDFL  0x400000
+#define CO_FUTURE_GENERATOR_STOP  0x800000
+#define CO_FUTURE_ANNOTATIONS    0x1000000
+
+/* This value is found in the co_cell2arg array when the associated cell
+   variable does not correspond to an argument. */
+#define CO_CELL_NOT_AN_ARG (-1)
+
+/* This should be defined if a future statement modifies the syntax.
+   For example, when a keyword is added.
+*/
+#define PY_PARSER_REQUIRES_FUTURE_KEYWORD
+
+#define CO_MAXBLOCKS 20 /* Max static block nesting within a function */
+
+PyAPI_DATA(PyTypeObject) PyCode_Type;
+
+#define PyCode_Check(op) Py_IS_TYPE(op, &PyCode_Type)
+#define PyCode_GetNumFree(op) (PyTuple_GET_SIZE((op)->co_freevars))
+
+/* Public interface */
+PyAPI_FUNC(PyCodeObject *) PyCode_New(
+        int, int, int, int, int, PyObject *, PyObject *,
+        PyObject *, PyObject *, PyObject *, PyObject *,
+        PyObject *, PyObject *, int, PyObject *);
+
+PyAPI_FUNC(PyCodeObject *) PyCode_NewWithPosOnlyArgs(
+        int, int, int, int, int, int, PyObject *, PyObject *,
+        PyObject *, PyObject *, PyObject *, PyObject *,
+        PyObject *, PyObject *, int, PyObject *);
+        /* same as struct above */
+
+/* Creates a new empty code object with the specified source location. */
+PyAPI_FUNC(PyCodeObject *)
+PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno);
+
+/* Return the line number associated with the specified bytecode index
+   in this code object.  If you just need the line number of a frame,
+   use PyFrame_GetLineNumber() instead. */
+PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int);
+
+/* for internal use only */
+typedef struct _addr_pair {
+        int ap_lower;
+        int ap_upper;
+} PyAddrPair;
+
+/* Update *bounds to describe the first and one-past-the-last instructions in the
+   same line as lasti.  Return the number of that line.
+*/
+PyAPI_FUNC(int) _PyCode_CheckLineNumber(PyCodeObject* co,
+                                        int lasti, PyAddrPair *bounds);
+
+/* Create a comparable key used to compare constants taking in account the
+ * object type. It is used to make sure types are not coerced (e.g., float and
+ * complex) _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms
+ *
+ * Return (type(obj), obj, ...): a tuple with variable size (at least 2 items)
+ * depending on the type and the value. The type is the first item to not
+ * compare bytes and str which can raise a BytesWarning exception. */
+PyAPI_FUNC(PyObject*) _PyCode_ConstantKey(PyObject *obj);
+
+PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts,
+                                      PyObject *names, PyObject *lnotab);
+
+
+PyAPI_FUNC(int) _PyCode_GetExtra(PyObject *code, Py_ssize_t index,
+                                 void **extra);
+PyAPI_FUNC(int) _PyCode_SetExtra(PyObject *code, Py_ssize_t index,
+                                 void *extra);
diff --git a/contrib/tools/python3/src/Include/cpython/dictobject.h b/contrib/tools/python3/src/Include/cpython/dictobject.h
index 29cd73080d..50f4c4a9e5 100644
--- a/contrib/tools/python3/src/Include/cpython/dictobject.h
+++ b/contrib/tools/python3/src/Include/cpython/dictobject.h
@@ -1,92 +1,92 @@
-#ifndef Py_CPYTHON_DICTOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-typedef struct _dictkeysobject PyDictKeysObject; 
- 
-/* The ma_values pointer is NULL for a combined table 
- * or points to an array of PyObject* for a split table 
- */ 
-typedef struct { 
-    PyObject_HEAD 
- 
-    /* Number of items in the dictionary */ 
-    Py_ssize_t ma_used; 
- 
-    /* Dictionary version: globally unique, value change each time 
-       the dictionary is modified */ 
-    uint64_t ma_version_tag; 
- 
-    PyDictKeysObject *ma_keys; 
- 
-    /* If ma_values is NULL, the table is "combined": keys and values 
-       are stored in ma_keys. 
- 
-       If ma_values is not NULL, the table is split: 
-       keys are stored in ma_keys and values are stored in ma_values */ 
-    PyObject **ma_values; 
-} PyDictObject; 
- 
-PyAPI_FUNC(PyObject *) _PyDict_GetItem_KnownHash(PyObject *mp, PyObject *key, 
-                                       Py_hash_t hash); 
-PyAPI_FUNC(PyObject *) _PyDict_GetItemIdWithError(PyObject *dp, 
-                                                  struct _Py_Identifier *key); 
-PyAPI_FUNC(PyObject *) _PyDict_GetItemStringWithError(PyObject *, const char *); 
-PyAPI_FUNC(PyObject *) PyDict_SetDefault( 
-    PyObject *mp, PyObject *key, PyObject *defaultobj); 
-PyAPI_FUNC(int) _PyDict_SetItem_KnownHash(PyObject *mp, PyObject *key, 
-                                          PyObject *item, Py_hash_t hash); 
-PyAPI_FUNC(int) _PyDict_DelItem_KnownHash(PyObject *mp, PyObject *key, 
-                                          Py_hash_t hash); 
-PyAPI_FUNC(int) _PyDict_DelItemIf(PyObject *mp, PyObject *key, 
-                                  int (*predicate)(PyObject *value)); 
-PyDictKeysObject *_PyDict_NewKeysForClass(void); 
-PyAPI_FUNC(PyObject *) PyObject_GenericGetDict(PyObject *, void *); 
-PyAPI_FUNC(int) _PyDict_Next( 
-    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, Py_hash_t *hash); 
- 
-/* Get the number of items of a dictionary. */ 
-#define PyDict_GET_SIZE(mp)  (assert(PyDict_Check(mp)),((PyDictObject *)mp)->ma_used) 
-PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, Py_hash_t hash); 
-PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused); 
-PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp); 
-PyAPI_FUNC(int) _PyDict_HasOnlyStringKeys(PyObject *mp); 
-Py_ssize_t _PyDict_KeysSize(PyDictKeysObject *keys); 
-PyAPI_FUNC(Py_ssize_t) _PyDict_SizeOf(PyDictObject *); 
-PyAPI_FUNC(PyObject *) _PyDict_Pop(PyObject *, PyObject *, PyObject *); 
-PyObject *_PyDict_Pop_KnownHash(PyObject *, PyObject *, Py_hash_t, PyObject *); 
-PyObject *_PyDict_FromKeys(PyObject *, PyObject *, PyObject *); 
-#define _PyDict_HasSplitTable(d) ((d)->ma_values != NULL) 
- 
-/* Like PyDict_Merge, but override can be 0, 1 or 2.  If override is 0, 
-   the first occurrence of a key wins, if override is 1, the last occurrence 
-   of a key wins, if override is 2, a KeyError with conflicting key as 
-   argument is raised. 
-*/ 
-PyAPI_FUNC(int) _PyDict_MergeEx(PyObject *mp, PyObject *other, int override); 
-PyAPI_FUNC(PyObject *) _PyDict_GetItemId(PyObject *dp, struct _Py_Identifier *key); 
-PyAPI_FUNC(int) _PyDict_SetItemId(PyObject *dp, struct _Py_Identifier *key, PyObject *item); 
- 
-PyAPI_FUNC(int) _PyDict_DelItemId(PyObject *mp, struct _Py_Identifier *key); 
-PyAPI_FUNC(void) _PyDict_DebugMallocStats(FILE *out); 
- 
-int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject **dictptr, PyObject *name, PyObject *value); 
-PyObject *_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *); 
- 
-/* _PyDictView */ 
- 
-typedef struct { 
-    PyObject_HEAD 
-    PyDictObject *dv_dict; 
-} _PyDictViewObject; 
- 
-PyAPI_FUNC(PyObject *) _PyDictView_New(PyObject *, PyTypeObject *); 
-PyAPI_FUNC(PyObject *) _PyDictView_Intersect(PyObject* self, PyObject *other); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_DICTOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _dictkeysobject PyDictKeysObject;
+
+/* The ma_values pointer is NULL for a combined table
+ * or points to an array of PyObject* for a split table
+ */
+typedef struct {
+    PyObject_HEAD
+
+    /* Number of items in the dictionary */
+    Py_ssize_t ma_used;
+
+    /* Dictionary version: globally unique, value change each time
+       the dictionary is modified */
+    uint64_t ma_version_tag;
+
+    PyDictKeysObject *ma_keys;
+
+    /* If ma_values is NULL, the table is "combined": keys and values
+       are stored in ma_keys.
+
+       If ma_values is not NULL, the table is split:
+       keys are stored in ma_keys and values are stored in ma_values */
+    PyObject **ma_values;
+} PyDictObject;
+
+PyAPI_FUNC(PyObject *) _PyDict_GetItem_KnownHash(PyObject *mp, PyObject *key,
+                                       Py_hash_t hash);
+PyAPI_FUNC(PyObject *) _PyDict_GetItemIdWithError(PyObject *dp,
+                                                  struct _Py_Identifier *key);
+PyAPI_FUNC(PyObject *) _PyDict_GetItemStringWithError(PyObject *, const char *);
+PyAPI_FUNC(PyObject *) PyDict_SetDefault(
+    PyObject *mp, PyObject *key, PyObject *defaultobj);
+PyAPI_FUNC(int) _PyDict_SetItem_KnownHash(PyObject *mp, PyObject *key,
+                                          PyObject *item, Py_hash_t hash);
+PyAPI_FUNC(int) _PyDict_DelItem_KnownHash(PyObject *mp, PyObject *key,
+                                          Py_hash_t hash);
+PyAPI_FUNC(int) _PyDict_DelItemIf(PyObject *mp, PyObject *key,
+                                  int (*predicate)(PyObject *value));
+PyDictKeysObject *_PyDict_NewKeysForClass(void);
+PyAPI_FUNC(PyObject *) PyObject_GenericGetDict(PyObject *, void *);
+PyAPI_FUNC(int) _PyDict_Next(
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, Py_hash_t *hash);
+
+/* Get the number of items of a dictionary. */
+#define PyDict_GET_SIZE(mp)  (assert(PyDict_Check(mp)),((PyDictObject *)mp)->ma_used)
+PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, Py_hash_t hash);
+PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused);
+PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp);
+PyAPI_FUNC(int) _PyDict_HasOnlyStringKeys(PyObject *mp);
+Py_ssize_t _PyDict_KeysSize(PyDictKeysObject *keys);
+PyAPI_FUNC(Py_ssize_t) _PyDict_SizeOf(PyDictObject *);
+PyAPI_FUNC(PyObject *) _PyDict_Pop(PyObject *, PyObject *, PyObject *);
+PyObject *_PyDict_Pop_KnownHash(PyObject *, PyObject *, Py_hash_t, PyObject *);
+PyObject *_PyDict_FromKeys(PyObject *, PyObject *, PyObject *);
+#define _PyDict_HasSplitTable(d) ((d)->ma_values != NULL)
+
+/* Like PyDict_Merge, but override can be 0, 1 or 2.  If override is 0,
+   the first occurrence of a key wins, if override is 1, the last occurrence
+   of a key wins, if override is 2, a KeyError with conflicting key as
+   argument is raised.
+*/
+PyAPI_FUNC(int) _PyDict_MergeEx(PyObject *mp, PyObject *other, int override);
+PyAPI_FUNC(PyObject *) _PyDict_GetItemId(PyObject *dp, struct _Py_Identifier *key);
+PyAPI_FUNC(int) _PyDict_SetItemId(PyObject *dp, struct _Py_Identifier *key, PyObject *item);
+
+PyAPI_FUNC(int) _PyDict_DelItemId(PyObject *mp, struct _Py_Identifier *key);
+PyAPI_FUNC(void) _PyDict_DebugMallocStats(FILE *out);
+
+int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject **dictptr, PyObject *name, PyObject *value);
+PyObject *_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *);
+
+/* _PyDictView */
+
+typedef struct {
+    PyObject_HEAD
+    PyDictObject *dv_dict;
+} _PyDictViewObject;
+
+PyAPI_FUNC(PyObject *) _PyDictView_New(PyObject *, PyTypeObject *);
+PyAPI_FUNC(PyObject *) _PyDictView_Intersect(PyObject* self, PyObject *other);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/fileobject.h b/contrib/tools/python3/src/Include/cpython/fileobject.h
index c522cca1aa..3005ce1f00 100644
--- a/contrib/tools/python3/src/Include/cpython/fileobject.h
+++ b/contrib/tools/python3/src/Include/cpython/fileobject.h
@@ -1,24 +1,24 @@
-#ifndef Py_CPYTHON_FILEOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *); 
- 
-/* The std printer acts as a preliminary sys.stderr until the new io 
-   infrastructure is in place. */ 
-PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int); 
-PyAPI_DATA(PyTypeObject) PyStdPrinter_Type; 
- 
-typedef PyObject * (*Py_OpenCodeHookFunction)(PyObject *, void *); 
- 
-PyAPI_FUNC(PyObject *) PyFile_OpenCode(const char *utf8path); 
-PyAPI_FUNC(PyObject *) PyFile_OpenCodeObject(PyObject *path); 
-PyAPI_FUNC(int) PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_FILEOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);
+
+/* The std printer acts as a preliminary sys.stderr until the new io
+   infrastructure is in place. */
+PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int);
+PyAPI_DATA(PyTypeObject) PyStdPrinter_Type;
+
+typedef PyObject * (*Py_OpenCodeHookFunction)(PyObject *, void *);
+
+PyAPI_FUNC(PyObject *) PyFile_OpenCode(const char *utf8path);
+PyAPI_FUNC(PyObject *) PyFile_OpenCodeObject(PyObject *path);
+PyAPI_FUNC(int) PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/fileutils.h b/contrib/tools/python3/src/Include/cpython/fileutils.h
index 52d53756b2..e79d03e24f 100644
--- a/contrib/tools/python3/src/Include/cpython/fileutils.h
+++ b/contrib/tools/python3/src/Include/cpython/fileutils.h
@@ -1,165 +1,165 @@
-#ifndef Py_CPYTHON_FILEUTILS_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-typedef enum { 
-    _Py_ERROR_UNKNOWN=0, 
-    _Py_ERROR_STRICT, 
-    _Py_ERROR_SURROGATEESCAPE, 
-    _Py_ERROR_REPLACE, 
-    _Py_ERROR_IGNORE, 
-    _Py_ERROR_BACKSLASHREPLACE, 
-    _Py_ERROR_SURROGATEPASS, 
-    _Py_ERROR_XMLCHARREFREPLACE, 
-    _Py_ERROR_OTHER 
-} _Py_error_handler; 
- 
-PyAPI_FUNC(_Py_error_handler) _Py_GetErrorHandler(const char *errors); 
- 
-PyAPI_FUNC(int) _Py_DecodeLocaleEx( 
-    const char *arg, 
-    wchar_t **wstr, 
-    size_t *wlen, 
-    const char **reason, 
-    int current_locale, 
-    _Py_error_handler errors); 
- 
-PyAPI_FUNC(int) _Py_EncodeLocaleEx( 
-    const wchar_t *text, 
-    char **str, 
-    size_t *error_pos, 
-    const char **reason, 
-    int current_locale, 
-    _Py_error_handler errors); 
- 
- 
-PyAPI_FUNC(PyObject *) _Py_device_encoding(int); 
- 
-#if defined(MS_WINDOWS) || defined(__APPLE__) 
-    /* On Windows, the count parameter of read() is an int (bpo-9015, bpo-9611). 
-       On macOS 10.13, read() and write() with more than INT_MAX bytes 
-       fail with EINVAL (bpo-24658). */ 
-#   define _PY_READ_MAX  INT_MAX 
-#   define _PY_WRITE_MAX INT_MAX 
-#else 
-    /* write() should truncate the input to PY_SSIZE_T_MAX bytes, 
-       but it's safer to do it ourself to have a portable behaviour */ 
-#   define _PY_READ_MAX  PY_SSIZE_T_MAX 
-#   define _PY_WRITE_MAX PY_SSIZE_T_MAX 
-#endif 
- 
-#ifdef MS_WINDOWS 
-struct _Py_stat_struct { 
-    unsigned long st_dev; 
-    uint64_t st_ino; 
-    unsigned short st_mode; 
-    int st_nlink; 
-    int st_uid; 
-    int st_gid; 
-    unsigned long st_rdev; 
-    __int64 st_size; 
-    time_t st_atime; 
-    int st_atime_nsec; 
-    time_t st_mtime; 
-    int st_mtime_nsec; 
-    time_t st_ctime; 
-    int st_ctime_nsec; 
-    unsigned long st_file_attributes; 
-    unsigned long st_reparse_tag; 
-}; 
-#else 
-#  define _Py_stat_struct stat 
-#endif 
- 
-PyAPI_FUNC(int) _Py_fstat( 
-    int fd, 
-    struct _Py_stat_struct *status); 
- 
-PyAPI_FUNC(int) _Py_fstat_noraise( 
-    int fd, 
-    struct _Py_stat_struct *status); 
- 
-PyAPI_FUNC(int) _Py_stat( 
-    PyObject *path, 
-    struct stat *status); 
- 
-PyAPI_FUNC(int) _Py_open( 
-    const char *pathname, 
-    int flags); 
- 
-PyAPI_FUNC(int) _Py_open_noraise( 
-    const char *pathname, 
-    int flags); 
- 
-PyAPI_FUNC(FILE *) _Py_wfopen( 
-    const wchar_t *path, 
-    const wchar_t *mode); 
- 
-PyAPI_FUNC(FILE*) _Py_fopen( 
-    const char *pathname, 
-    const char *mode); 
- 
-PyAPI_FUNC(FILE*) _Py_fopen_obj( 
-    PyObject *path, 
-    const char *mode); 
- 
-PyAPI_FUNC(Py_ssize_t) _Py_read( 
-    int fd, 
-    void *buf, 
-    size_t count); 
- 
-PyAPI_FUNC(Py_ssize_t) _Py_write( 
-    int fd, 
-    const void *buf, 
-    size_t count); 
- 
-PyAPI_FUNC(Py_ssize_t) _Py_write_noraise( 
-    int fd, 
-    const void *buf, 
-    size_t count); 
- 
-#ifdef HAVE_READLINK 
-PyAPI_FUNC(int) _Py_wreadlink( 
-    const wchar_t *path, 
-    wchar_t *buf, 
-    /* Number of characters of 'buf' buffer 
-       including the trailing NUL character */ 
-    size_t buflen); 
-#endif 
- 
-#ifdef HAVE_REALPATH 
-PyAPI_FUNC(wchar_t*) _Py_wrealpath( 
-    const wchar_t *path, 
-    wchar_t *resolved_path, 
-    /* Number of characters of 'resolved_path' buffer 
-       including the trailing NUL character */ 
-    size_t resolved_path_len); 
-#endif 
- 
-#ifndef MS_WINDOWS 
-PyAPI_FUNC(int) _Py_isabs(const wchar_t *path); 
-#endif 
- 
-PyAPI_FUNC(int) _Py_abspath(const wchar_t *path, wchar_t **abspath_p); 
- 
-PyAPI_FUNC(wchar_t*) _Py_wgetcwd( 
-    wchar_t *buf, 
-    /* Number of characters of 'buf' buffer 
-       including the trailing NUL character */ 
-    size_t buflen); 
- 
-PyAPI_FUNC(int) _Py_get_inheritable(int fd); 
- 
-PyAPI_FUNC(int) _Py_set_inheritable(int fd, int inheritable, 
-                                    int *atomic_flag_works); 
- 
-PyAPI_FUNC(int) _Py_set_inheritable_async_safe(int fd, int inheritable, 
-                                               int *atomic_flag_works); 
- 
-PyAPI_FUNC(int) _Py_dup(int fd); 
- 
-#ifndef MS_WINDOWS 
-PyAPI_FUNC(int) _Py_get_blocking(int fd); 
- 
-PyAPI_FUNC(int) _Py_set_blocking(int fd, int blocking); 
-#endif   /* !MS_WINDOWS */ 
+#ifndef Py_CPYTHON_FILEUTILS_H
+#  error "this header file must not be included directly"
+#endif
+
+typedef enum {
+    _Py_ERROR_UNKNOWN=0,
+    _Py_ERROR_STRICT,
+    _Py_ERROR_SURROGATEESCAPE,
+    _Py_ERROR_REPLACE,
+    _Py_ERROR_IGNORE,
+    _Py_ERROR_BACKSLASHREPLACE,
+    _Py_ERROR_SURROGATEPASS,
+    _Py_ERROR_XMLCHARREFREPLACE,
+    _Py_ERROR_OTHER
+} _Py_error_handler;
+
+PyAPI_FUNC(_Py_error_handler) _Py_GetErrorHandler(const char *errors);
+
+PyAPI_FUNC(int) _Py_DecodeLocaleEx(
+    const char *arg,
+    wchar_t **wstr,
+    size_t *wlen,
+    const char **reason,
+    int current_locale,
+    _Py_error_handler errors);
+
+PyAPI_FUNC(int) _Py_EncodeLocaleEx(
+    const wchar_t *text,
+    char **str,
+    size_t *error_pos,
+    const char **reason,
+    int current_locale,
+    _Py_error_handler errors);
+
+
+PyAPI_FUNC(PyObject *) _Py_device_encoding(int);
+
+#if defined(MS_WINDOWS) || defined(__APPLE__)
+    /* On Windows, the count parameter of read() is an int (bpo-9015, bpo-9611).
+       On macOS 10.13, read() and write() with more than INT_MAX bytes
+       fail with EINVAL (bpo-24658). */
+#   define _PY_READ_MAX  INT_MAX
+#   define _PY_WRITE_MAX INT_MAX
+#else
+    /* write() should truncate the input to PY_SSIZE_T_MAX bytes,
+       but it's safer to do it ourself to have a portable behaviour */
+#   define _PY_READ_MAX  PY_SSIZE_T_MAX
+#   define _PY_WRITE_MAX PY_SSIZE_T_MAX
+#endif
+
+#ifdef MS_WINDOWS
+struct _Py_stat_struct {
+    unsigned long st_dev;
+    uint64_t st_ino;
+    unsigned short st_mode;
+    int st_nlink;
+    int st_uid;
+    int st_gid;
+    unsigned long st_rdev;
+    __int64 st_size;
+    time_t st_atime;
+    int st_atime_nsec;
+    time_t st_mtime;
+    int st_mtime_nsec;
+    time_t st_ctime;
+    int st_ctime_nsec;
+    unsigned long st_file_attributes;
+    unsigned long st_reparse_tag;
+};
+#else
+#  define _Py_stat_struct stat
+#endif
+
+PyAPI_FUNC(int) _Py_fstat(
+    int fd,
+    struct _Py_stat_struct *status);
+
+PyAPI_FUNC(int) _Py_fstat_noraise(
+    int fd,
+    struct _Py_stat_struct *status);
+
+PyAPI_FUNC(int) _Py_stat(
+    PyObject *path,
+    struct stat *status);
+
+PyAPI_FUNC(int) _Py_open(
+    const char *pathname,
+    int flags);
+
+PyAPI_FUNC(int) _Py_open_noraise(
+    const char *pathname,
+    int flags);
+
+PyAPI_FUNC(FILE *) _Py_wfopen(
+    const wchar_t *path,
+    const wchar_t *mode);
+
+PyAPI_FUNC(FILE*) _Py_fopen(
+    const char *pathname,
+    const char *mode);
+
+PyAPI_FUNC(FILE*) _Py_fopen_obj(
+    PyObject *path,
+    const char *mode);
+
+PyAPI_FUNC(Py_ssize_t) _Py_read(
+    int fd,
+    void *buf,
+    size_t count);
+
+PyAPI_FUNC(Py_ssize_t) _Py_write(
+    int fd,
+    const void *buf,
+    size_t count);
+
+PyAPI_FUNC(Py_ssize_t) _Py_write_noraise(
+    int fd,
+    const void *buf,
+    size_t count);
+
+#ifdef HAVE_READLINK
+PyAPI_FUNC(int) _Py_wreadlink(
+    const wchar_t *path,
+    wchar_t *buf,
+    /* Number of characters of 'buf' buffer
+       including the trailing NUL character */
+    size_t buflen);
+#endif
+
+#ifdef HAVE_REALPATH
+PyAPI_FUNC(wchar_t*) _Py_wrealpath(
+    const wchar_t *path,
+    wchar_t *resolved_path,
+    /* Number of characters of 'resolved_path' buffer
+       including the trailing NUL character */
+    size_t resolved_path_len);
+#endif
+
+#ifndef MS_WINDOWS
+PyAPI_FUNC(int) _Py_isabs(const wchar_t *path);
+#endif
+
+PyAPI_FUNC(int) _Py_abspath(const wchar_t *path, wchar_t **abspath_p);
+
+PyAPI_FUNC(wchar_t*) _Py_wgetcwd(
+    wchar_t *buf,
+    /* Number of characters of 'buf' buffer
+       including the trailing NUL character */
+    size_t buflen);
+
+PyAPI_FUNC(int) _Py_get_inheritable(int fd);
+
+PyAPI_FUNC(int) _Py_set_inheritable(int fd, int inheritable,
+                                    int *atomic_flag_works);
+
+PyAPI_FUNC(int) _Py_set_inheritable_async_safe(int fd, int inheritable,
+                                               int *atomic_flag_works);
+
+PyAPI_FUNC(int) _Py_dup(int fd);
+
+#ifndef MS_WINDOWS
+PyAPI_FUNC(int) _Py_get_blocking(int fd);
+
+PyAPI_FUNC(int) _Py_set_blocking(int fd, int blocking);
+#endif   /* !MS_WINDOWS */
diff --git a/contrib/tools/python3/src/Include/cpython/frameobject.h b/contrib/tools/python3/src/Include/cpython/frameobject.h
index b303ad0558..36a51baae8 100644
--- a/contrib/tools/python3/src/Include/cpython/frameobject.h
+++ b/contrib/tools/python3/src/Include/cpython/frameobject.h
@@ -1,84 +1,84 @@
-/* Frame object interface */ 
- 
-#ifndef Py_CPYTHON_FRAMEOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-typedef struct { 
-    int b_type;                 /* what kind of block this is */ 
-    int b_handler;              /* where to jump to find handler */ 
-    int b_level;                /* value stack level to pop to */ 
-} PyTryBlock; 
- 
-struct _frame { 
-    PyObject_VAR_HEAD 
-    struct _frame *f_back;      /* previous frame, or NULL */ 
-    PyCodeObject *f_code;       /* code segment */ 
-    PyObject *f_builtins;       /* builtin symbol table (PyDictObject) */ 
-    PyObject *f_globals;        /* global symbol table (PyDictObject) */ 
-    PyObject *f_locals;         /* local symbol table (any mapping) */ 
-    PyObject **f_valuestack;    /* points after the last local */ 
-    /* Next free slot in f_valuestack.  Frame creation sets to f_valuestack. 
-       Frame evaluation usually NULLs it, but a frame that yields sets it 
-       to the current stack top. */ 
-    PyObject **f_stacktop; 
-    PyObject *f_trace;          /* Trace function */ 
-    char f_trace_lines;         /* Emit per-line trace events? */ 
-    char f_trace_opcodes;       /* Emit per-opcode trace events? */ 
- 
-    /* Borrowed reference to a generator, or NULL */ 
-    PyObject *f_gen; 
- 
-    int f_lasti;                /* Last instruction if called */ 
-    /* Call PyFrame_GetLineNumber() instead of reading this field 
-       directly.  As of 2.3 f_lineno is only valid when tracing is 
-       active (i.e. when f_trace is set).  At other times we use 
-       PyCode_Addr2Line to calculate the line from the current 
-       bytecode index. */ 
-    int f_lineno;               /* Current line number */ 
-    int f_iblock;               /* index in f_blockstack */ 
-    char f_executing;           /* whether the frame is still executing */ 
-    PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ 
-    PyObject *f_localsplus[1];  /* locals+stack, dynamically sized */ 
-}; 
- 
- 
-/* Standard object interface */ 
- 
-PyAPI_DATA(PyTypeObject) PyFrame_Type; 
- 
-#define PyFrame_Check(op) Py_IS_TYPE(op, &PyFrame_Type) 
- 
-PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *, 
-                                        PyObject *, PyObject *); 
- 
-/* only internal use */ 
-PyFrameObject* _PyFrame_New_NoTrack(PyThreadState *, PyCodeObject *, 
-                                    PyObject *, PyObject *); 
- 
- 
-/* The rest of the interface is specific for frame objects */ 
- 
-/* Block management functions */ 
- 
-PyAPI_FUNC(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int); 
-PyAPI_FUNC(PyTryBlock *) PyFrame_BlockPop(PyFrameObject *); 
- 
-/* Conversions between "fast locals" and locals in dictionary */ 
- 
-PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int); 
- 
-PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f); 
-PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *); 
- 
-PyAPI_FUNC(void) _PyFrame_DebugMallocStats(FILE *out); 
- 
-PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+/* Frame object interface */
+
+#ifndef Py_CPYTHON_FRAMEOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    int b_type;                 /* what kind of block this is */
+    int b_handler;              /* where to jump to find handler */
+    int b_level;                /* value stack level to pop to */
+} PyTryBlock;
+
+struct _frame {
+    PyObject_VAR_HEAD
+    struct _frame *f_back;      /* previous frame, or NULL */
+    PyCodeObject *f_code;       /* code segment */
+    PyObject *f_builtins;       /* builtin symbol table (PyDictObject) */
+    PyObject *f_globals;        /* global symbol table (PyDictObject) */
+    PyObject *f_locals;         /* local symbol table (any mapping) */
+    PyObject **f_valuestack;    /* points after the last local */
+    /* Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
+       Frame evaluation usually NULLs it, but a frame that yields sets it
+       to the current stack top. */
+    PyObject **f_stacktop;
+    PyObject *f_trace;          /* Trace function */
+    char f_trace_lines;         /* Emit per-line trace events? */
+    char f_trace_opcodes;       /* Emit per-opcode trace events? */
+
+    /* Borrowed reference to a generator, or NULL */
+    PyObject *f_gen;
+
+    int f_lasti;                /* Last instruction if called */
+    /* Call PyFrame_GetLineNumber() instead of reading this field
+       directly.  As of 2.3 f_lineno is only valid when tracing is
+       active (i.e. when f_trace is set).  At other times we use
+       PyCode_Addr2Line to calculate the line from the current
+       bytecode index. */
+    int f_lineno;               /* Current line number */
+    int f_iblock;               /* index in f_blockstack */
+    char f_executing;           /* whether the frame is still executing */
+    PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
+    PyObject *f_localsplus[1];  /* locals+stack, dynamically sized */
+};
+
+
+/* Standard object interface */
+
+PyAPI_DATA(PyTypeObject) PyFrame_Type;
+
+#define PyFrame_Check(op) Py_IS_TYPE(op, &PyFrame_Type)
+
+PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *,
+                                        PyObject *, PyObject *);
+
+/* only internal use */
+PyFrameObject* _PyFrame_New_NoTrack(PyThreadState *, PyCodeObject *,
+                                    PyObject *, PyObject *);
+
+
+/* The rest of the interface is specific for frame objects */
+
+/* Block management functions */
+
+PyAPI_FUNC(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int);
+PyAPI_FUNC(PyTryBlock *) PyFrame_BlockPop(PyFrameObject *);
+
+/* Conversions between "fast locals" and locals in dictionary */
+
+PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int);
+
+PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f);
+PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *);
+
+PyAPI_FUNC(void) _PyFrame_DebugMallocStats(FILE *out);
+
+PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/import.h b/contrib/tools/python3/src/Include/cpython/import.h
index c80856847c..c1b47121f1 100644
--- a/contrib/tools/python3/src/Include/cpython/import.h
+++ b/contrib/tools/python3/src/Include/cpython/import.h
@@ -1,50 +1,50 @@
-#ifndef Py_CPYTHON_IMPORT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-PyMODINIT_FUNC PyInit__imp(void); 
- 
-PyAPI_FUNC(int) _PyImport_IsInitialized(PyInterpreterState *); 
- 
-PyAPI_FUNC(PyObject *) _PyImport_GetModuleId(struct _Py_Identifier *name); 
-PyAPI_FUNC(int) _PyImport_SetModule(PyObject *name, PyObject *module); 
-PyAPI_FUNC(int) _PyImport_SetModuleString(const char *name, PyObject* module); 
- 
-PyAPI_FUNC(void) _PyImport_AcquireLock(void); 
-PyAPI_FUNC(int) _PyImport_ReleaseLock(void); 
- 
-PyAPI_FUNC(PyObject *) _PyImport_FindExtensionObject(PyObject *, PyObject *); 
- 
-PyAPI_FUNC(int) _PyImport_FixupBuiltin( 
-    PyObject *mod, 
-    const char *name,            /* UTF-8 encoded string */ 
-    PyObject *modules 
-    ); 
-PyAPI_FUNC(int) _PyImport_FixupExtensionObject(PyObject*, PyObject *, 
-                                               PyObject *, PyObject *); 
- 
-struct _inittab { 
-    const char *name;           /* ASCII encoded string */ 
-    PyObject* (*initfunc)(void); 
-}; 
-PyAPI_DATA(struct _inittab *) PyImport_Inittab; 
-PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab); 
- 
-struct _frozen { 
-    const char *name;                 /* ASCII encoded string */ 
-    const unsigned char *code; 
-    int size; 
-}; 
- 
-/* Embedding apps may change this pointer to point to their favorite 
-   collection of frozen modules: */ 
- 
-PyAPI_DATA(const struct _frozen *) PyImport_FrozenModules; 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_IMPORT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyMODINIT_FUNC PyInit__imp(void);
+
+PyAPI_FUNC(int) _PyImport_IsInitialized(PyInterpreterState *);
+
+PyAPI_FUNC(PyObject *) _PyImport_GetModuleId(struct _Py_Identifier *name);
+PyAPI_FUNC(int) _PyImport_SetModule(PyObject *name, PyObject *module);
+PyAPI_FUNC(int) _PyImport_SetModuleString(const char *name, PyObject* module);
+
+PyAPI_FUNC(void) _PyImport_AcquireLock(void);
+PyAPI_FUNC(int) _PyImport_ReleaseLock(void);
+
+PyAPI_FUNC(PyObject *) _PyImport_FindExtensionObject(PyObject *, PyObject *);
+
+PyAPI_FUNC(int) _PyImport_FixupBuiltin(
+    PyObject *mod,
+    const char *name,            /* UTF-8 encoded string */
+    PyObject *modules
+    );
+PyAPI_FUNC(int) _PyImport_FixupExtensionObject(PyObject*, PyObject *,
+                                               PyObject *, PyObject *);
+
+struct _inittab {
+    const char *name;           /* ASCII encoded string */
+    PyObject* (*initfunc)(void);
+};
+PyAPI_DATA(struct _inittab *) PyImport_Inittab;
+PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab);
+
+struct _frozen {
+    const char *name;                 /* ASCII encoded string */
+    const unsigned char *code;
+    int size;
+};
+
+/* Embedding apps may change this pointer to point to their favorite
+   collection of frozen modules: */
+
+PyAPI_DATA(const struct _frozen *) PyImport_FrozenModules;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/initconfig.h b/contrib/tools/python3/src/Include/cpython/initconfig.h
index 5a4009f553..0a256d4b5b 100644
--- a/contrib/tools/python3/src/Include/cpython/initconfig.h
+++ b/contrib/tools/python3/src/Include/cpython/initconfig.h
@@ -1,462 +1,462 @@
-#ifndef Py_PYCORECONFIG_H 
-#define Py_PYCORECONFIG_H 
-#ifndef Py_LIMITED_API 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-/* --- PyStatus ----------------------------------------------- */ 
- 
-typedef struct { 
-    enum { 
-        _PyStatus_TYPE_OK=0, 
-        _PyStatus_TYPE_ERROR=1, 
-        _PyStatus_TYPE_EXIT=2 
-    } _type; 
-    const char *func; 
-    const char *err_msg; 
-    int exitcode; 
-} PyStatus; 
- 
-PyAPI_FUNC(PyStatus) PyStatus_Ok(void); 
-PyAPI_FUNC(PyStatus) PyStatus_Error(const char *err_msg); 
-PyAPI_FUNC(PyStatus) PyStatus_NoMemory(void); 
-PyAPI_FUNC(PyStatus) PyStatus_Exit(int exitcode); 
-PyAPI_FUNC(int) PyStatus_IsError(PyStatus err); 
-PyAPI_FUNC(int) PyStatus_IsExit(PyStatus err); 
-PyAPI_FUNC(int) PyStatus_Exception(PyStatus err); 
- 
-/* --- PyWideStringList ------------------------------------------------ */ 
- 
-typedef struct { 
-    /* If length is greater than zero, items must be non-NULL 
-       and all items strings must be non-NULL */ 
-    Py_ssize_t length; 
-    wchar_t **items; 
-} PyWideStringList; 
- 
-PyAPI_FUNC(PyStatus) PyWideStringList_Append(PyWideStringList *list, 
-    const wchar_t *item); 
-PyAPI_FUNC(PyStatus) PyWideStringList_Insert(PyWideStringList *list, 
-    Py_ssize_t index, 
-    const wchar_t *item); 
- 
- 
-/* --- PyPreConfig ----------------------------------------------- */ 
- 
-typedef struct { 
-    int _config_init;     /* _PyConfigInitEnum value */ 
- 
-    /* Parse Py_PreInitializeFromBytesArgs() arguments? 
-       See PyConfig.parse_argv */ 
-    int parse_argv; 
- 
-    /* If greater than 0, enable isolated mode: sys.path contains 
-       neither the script's directory nor the user's site-packages directory. 
- 
-       Set to 1 by the -I command line option. If set to -1 (default), inherit 
-       Py_IsolatedFlag value. */ 
-    int isolated; 
- 
-    /* If greater than 0: use environment variables. 
-       Set to 0 by -E command line option. If set to -1 (default), it is 
-       set to !Py_IgnoreEnvironmentFlag. */ 
-    int use_environment; 
- 
-    /* Set the LC_CTYPE locale to the user preferred locale? If equals to 0, 
-       set coerce_c_locale and coerce_c_locale_warn to 0. */ 
-    int configure_locale; 
- 
-    /* Coerce the LC_CTYPE locale if it's equal to "C"? (PEP 538) 
- 
-       Set to 0 by PYTHONCOERCECLOCALE=0. Set to 1 by PYTHONCOERCECLOCALE=1. 
-       Set to 2 if the user preferred LC_CTYPE locale is "C". 
- 
-       If it is equal to 1, LC_CTYPE locale is read to decide if it should be 
-       coerced or not (ex: PYTHONCOERCECLOCALE=1). Internally, it is set to 2 
-       if the LC_CTYPE locale must be coerced. 
- 
-       Disable by default (set to 0). Set it to -1 to let Python decide if it 
-       should be enabled or not. */ 
-    int coerce_c_locale; 
- 
-    /* Emit a warning if the LC_CTYPE locale is coerced? 
- 
-       Set to 1 by PYTHONCOERCECLOCALE=warn. 
- 
-       Disable by default (set to 0). Set it to -1 to let Python decide if it 
-       should be enabled or not. */ 
-    int coerce_c_locale_warn; 
- 
-#ifdef MS_WINDOWS 
-    /* If greater than 1, use the "mbcs" encoding instead of the UTF-8 
-       encoding for the filesystem encoding. 
- 
-       Set to 1 if the PYTHONLEGACYWINDOWSFSENCODING environment variable is 
-       set to a non-empty string. If set to -1 (default), inherit 
-       Py_LegacyWindowsFSEncodingFlag value. 
- 
-       See PEP 529 for more details. */ 
-    int legacy_windows_fs_encoding; 
-#endif 
- 
-    /* Enable UTF-8 mode? (PEP 540) 
- 
-       Disabled by default (equals to 0). 
- 
-       Set to 1 by "-X utf8" and "-X utf8=1" command line options. 
-       Set to 1 by PYTHONUTF8=1 environment variable. 
- 
-       Set to 0 by "-X utf8=0" and PYTHONUTF8=0. 
- 
-       If equals to -1, it is set to 1 if the LC_CTYPE locale is "C" or 
-       "POSIX", otherwise it is set to 0. Inherit Py_UTF8Mode value value. */ 
-    int utf8_mode; 
- 
-    /* If non-zero, enable the Python Development Mode. 
- 
-       Set to 1 by the -X dev command line option. Set by the PYTHONDEVMODE 
-       environment variable. */ 
-    int dev_mode; 
- 
-    /* Memory allocator: PYTHONMALLOC env var. 
-       See PyMemAllocatorName for valid values. */ 
-    int allocator; 
-} PyPreConfig; 
- 
-PyAPI_FUNC(void) PyPreConfig_InitPythonConfig(PyPreConfig *config); 
-PyAPI_FUNC(void) PyPreConfig_InitIsolatedConfig(PyPreConfig *config); 
- 
- 
-/* --- PyConfig ---------------------------------------------- */ 
- 
-typedef struct { 
-    int _config_init;     /* _PyConfigInitEnum value */ 
- 
-    int isolated;         /* Isolated mode? see PyPreConfig.isolated */ 
-    int use_environment;  /* Use environment variables? see PyPreConfig.use_environment */ 
-    int dev_mode;         /* Python Development Mode? See PyPreConfig.dev_mode */ 
- 
-    /* Install signal handlers? Yes by default. */ 
-    int install_signal_handlers; 
- 
-    int use_hash_seed;      /* PYTHONHASHSEED=x */ 
-    unsigned long hash_seed; 
- 
-    /* Enable faulthandler? 
-       Set to 1 by -X faulthandler and PYTHONFAULTHANDLER. -1 means unset. */ 
-    int faulthandler; 
- 
-    /* Enable PEG parser? 
-       1 by default, set to 0 by -X oldparser and PYTHONOLDPARSER */ 
-    int _use_peg_parser; 
- 
-    /* Enable tracemalloc? 
-       Set by -X tracemalloc=N and PYTHONTRACEMALLOC. -1 means unset */ 
-    int tracemalloc; 
- 
-    int import_time;        /* PYTHONPROFILEIMPORTTIME, -X importtime */ 
-    int show_ref_count;     /* -X showrefcount */ 
-    int dump_refs;          /* PYTHONDUMPREFS */ 
-    int malloc_stats;       /* PYTHONMALLOCSTATS */ 
- 
-    /* Python filesystem encoding and error handler: 
-       sys.getfilesystemencoding() and sys.getfilesystemencodeerrors(). 
- 
-       Default encoding and error handler: 
- 
-       * if Py_SetStandardStreamEncoding() has been called: they have the 
-         highest priority; 
-       * PYTHONIOENCODING environment variable; 
-       * The UTF-8 Mode uses UTF-8/surrogateescape; 
-       * If Python forces the usage of the ASCII encoding (ex: C locale 
-         or POSIX locale on FreeBSD or HP-UX), use ASCII/surrogateescape; 
-       * locale encoding: ANSI code page on Windows, UTF-8 on Android and 
-         VxWorks, LC_CTYPE locale encoding on other platforms; 
-       * On Windows, "surrogateescape" error handler; 
-       * "surrogateescape" error handler if the LC_CTYPE locale is "C" or "POSIX"; 
-       * "surrogateescape" error handler if the LC_CTYPE locale has been coerced 
-         (PEP 538); 
-       * "strict" error handler. 
- 
-       Supported error handlers: "strict", "surrogateescape" and 
-       "surrogatepass". The surrogatepass error handler is only supported 
-       if Py_DecodeLocale() and Py_EncodeLocale() use directly the UTF-8 codec; 
-       it's only used on Windows. 
- 
-       initfsencoding() updates the encoding to the Python codec name. 
-       For example, "ANSI_X3.4-1968" is replaced with "ascii". 
- 
-       On Windows, sys._enablelegacywindowsfsencoding() sets the 
-       encoding/errors to mbcs/replace at runtime. 
- 
- 
-       See Py_FileSystemDefaultEncoding and Py_FileSystemDefaultEncodeErrors. 
-       */ 
-    wchar_t *filesystem_encoding; 
-    wchar_t *filesystem_errors; 
- 
-    wchar_t *pycache_prefix;  /* PYTHONPYCACHEPREFIX, -X pycache_prefix=PATH */ 
-    int parse_argv;           /* Parse argv command line arguments? */ 
- 
-    /* Command line arguments (sys.argv). 
- 
-       Set parse_argv to 1 to parse argv as Python command line arguments 
-       and then strip Python arguments from argv. 
- 
-       If argv is empty, an empty string is added to ensure that sys.argv 
-       always exists and is never empty. */ 
-    PyWideStringList argv; 
- 
-    /* Program name: 
- 
-       - If Py_SetProgramName() was called, use its value. 
-       - On macOS, use PYTHONEXECUTABLE environment variable if set. 
-       - If WITH_NEXT_FRAMEWORK macro is defined, use __PYVENV_LAUNCHER__ 
-         environment variable is set. 
-       - Use argv[0] if available and non-empty. 
-       - Use "python" on Windows, or "python3 on other platforms. */ 
-    wchar_t *program_name; 
- 
-    PyWideStringList xoptions;     /* Command line -X options */ 
- 
-    /* Warnings options: lowest to highest priority. warnings.filters 
-       is built in the reverse order (highest to lowest priority). */ 
-    PyWideStringList warnoptions; 
- 
-    /* If equal to zero, disable the import of the module site and the 
-       site-dependent manipulations of sys.path that it entails. Also disable 
-       these manipulations if site is explicitly imported later (call 
-       site.main() if you want them to be triggered). 
- 
-       Set to 0 by the -S command line option. If set to -1 (default), it is 
-       set to !Py_NoSiteFlag. */ 
-    int site_import; 
- 
-    /* Bytes warnings: 
- 
-       * If equal to 1, issue a warning when comparing bytes or bytearray with 
-         str or bytes with int. 
-       * If equal or greater to 2, issue an error. 
- 
-       Incremented by the -b command line option. If set to -1 (default), inherit 
-       Py_BytesWarningFlag value. */ 
-    int bytes_warning; 
- 
-    /* If greater than 0, enable inspect: when a script is passed as first 
-       argument or the -c option is used, enter interactive mode after 
-       executing the script or the command, even when sys.stdin does not appear 
-       to be a terminal. 
- 
-       Incremented by the -i command line option. Set to 1 if the PYTHONINSPECT 
-       environment variable is non-empty. If set to -1 (default), inherit 
-       Py_InspectFlag value. */ 
-    int inspect; 
- 
-    /* If greater than 0: enable the interactive mode (REPL). 
- 
-       Incremented by the -i command line option. If set to -1 (default), 
-       inherit Py_InteractiveFlag value. */ 
-    int interactive; 
- 
-    /* Optimization level. 
- 
-       Incremented by the -O command line option. Set by the PYTHONOPTIMIZE 
-       environment variable. If set to -1 (default), inherit Py_OptimizeFlag 
-       value. */ 
-    int optimization_level; 
- 
-    /* If greater than 0, enable the debug mode: turn on parser debugging 
-       output (for expert only, depending on compilation options). 
- 
-       Incremented by the -d command line option. Set by the PYTHONDEBUG 
-       environment variable. If set to -1 (default), inherit Py_DebugFlag 
-       value. */ 
-    int parser_debug; 
- 
-    /* If equal to 0, Python won't try to write ``.pyc`` files on the 
-       import of source modules. 
- 
-       Set to 0 by the -B command line option and the PYTHONDONTWRITEBYTECODE 
-       environment variable. If set to -1 (default), it is set to 
-       !Py_DontWriteBytecodeFlag. */ 
-    int write_bytecode; 
- 
-    /* If greater than 0, enable the verbose mode: print a message each time a 
-       module is initialized, showing the place (filename or built-in module) 
-       from which it is loaded. 
- 
-       If greater or equal to 2, print a message for each file that is checked 
-       for when searching for a module. Also provides information on module 
-       cleanup at exit. 
- 
-       Incremented by the -v option. Set by the PYTHONVERBOSE environment 
-       variable. If set to -1 (default), inherit Py_VerboseFlag value. */ 
-    int verbose; 
- 
-    /* If greater than 0, enable the quiet mode: Don't display the copyright 
-       and version messages even in interactive mode. 
- 
-       Incremented by the -q option. If set to -1 (default), inherit 
-       Py_QuietFlag value. */ 
-    int quiet; 
- 
-   /* If greater than 0, don't add the user site-packages directory to 
-      sys.path. 
- 
-      Set to 0 by the -s and -I command line options , and the PYTHONNOUSERSITE 
-      environment variable. If set to -1 (default), it is set to 
-      !Py_NoUserSiteDirectory. */ 
-    int user_site_directory; 
- 
-    /* If non-zero, configure C standard steams (stdio, stdout, 
-       stderr): 
- 
-       - Set O_BINARY mode on Windows. 
-       - If buffered_stdio is equal to zero, make streams unbuffered. 
-         Otherwise, enable streams buffering if interactive is non-zero. */ 
-    int configure_c_stdio; 
- 
-    /* If equal to 0, enable unbuffered mode: force the stdout and stderr 
-       streams to be unbuffered. 
- 
-       Set to 0 by the -u option. Set by the PYTHONUNBUFFERED environment 
-       variable. 
-       If set to -1 (default), it is set to !Py_UnbufferedStdioFlag. */ 
-    int buffered_stdio; 
- 
-    /* Encoding of sys.stdin, sys.stdout and sys.stderr. 
-       Value set from PYTHONIOENCODING environment variable and 
-       Py_SetStandardStreamEncoding() function. 
-       See also 'stdio_errors' attribute. */ 
-    wchar_t *stdio_encoding; 
- 
-    /* Error handler of sys.stdin and sys.stdout. 
-       Value set from PYTHONIOENCODING environment variable and 
-       Py_SetStandardStreamEncoding() function. 
-       See also 'stdio_encoding' attribute. */ 
-    wchar_t *stdio_errors; 
- 
-#ifdef MS_WINDOWS 
-    /* If greater than zero, use io.FileIO instead of WindowsConsoleIO for sys 
-       standard streams. 
- 
-       Set to 1 if the PYTHONLEGACYWINDOWSSTDIO environment variable is set to 
-       a non-empty string. If set to -1 (default), inherit 
-       Py_LegacyWindowsStdioFlag value. 
- 
-       See PEP 528 for more details. */ 
-    int legacy_windows_stdio; 
-#endif 
- 
-    /* Value of the --check-hash-based-pycs command line option: 
- 
-       - "default" means the 'check_source' flag in hash-based pycs 
-         determines invalidation 
-       - "always" causes the interpreter to hash the source file for 
-         invalidation regardless of value of 'check_source' bit 
-       - "never" causes the interpreter to always assume hash-based pycs are 
-         valid 
- 
-       The default value is "default". 
- 
-       See PEP 552 "Deterministic pycs" for more details. */ 
-    wchar_t *check_hash_pycs_mode; 
- 
-    /* --- Path configuration inputs ------------ */ 
- 
-    /* If greater than 0, suppress _PyPathConfig_Calculate() warnings on Unix. 
-       The parameter has no effect on Windows. 
- 
-       If set to -1 (default), inherit !Py_FrozenFlag value. */ 
-    int pathconfig_warnings; 
- 
-    wchar_t *pythonpath_env; /* PYTHONPATH environment variable */ 
-    wchar_t *home;          /* PYTHONHOME environment variable, 
-                               see also Py_SetPythonHome(). */ 
- 
-    /* --- Path configuration outputs ----------- */ 
- 
-    int module_search_paths_set;  /* If non-zero, use module_search_paths */ 
-    PyWideStringList module_search_paths;  /* sys.path paths. Computed if 
-                                       module_search_paths_set is equal 
-                                       to zero. */ 
- 
-    wchar_t *executable;        /* sys.executable */ 
-    wchar_t *base_executable;   /* sys._base_executable */ 
-    wchar_t *prefix;            /* sys.prefix */ 
-    wchar_t *base_prefix;       /* sys.base_prefix */ 
-    wchar_t *exec_prefix;       /* sys.exec_prefix */ 
-    wchar_t *base_exec_prefix;  /* sys.base_exec_prefix */ 
-    wchar_t *platlibdir;        /* sys.platlibdir */ 
- 
-    /* --- Parameter only used by Py_Main() ---------- */ 
- 
-    /* Skip the first line of the source ('run_filename' parameter), allowing use of non-Unix forms of 
-       "#!cmd".  This is intended for a DOS specific hack only. 
- 
-       Set by the -x command line option. */ 
-    int skip_source_first_line; 
- 
-    wchar_t *run_command;   /* -c command line argument */ 
-    wchar_t *run_module;    /* -m command line argument */ 
-    wchar_t *run_filename;  /* Trailing command line argument without -c or -m */ 
- 
-    /* --- Private fields ---------------------------- */ 
- 
-    /* Install importlib? If set to 0, importlib is not initialized at all. 
-       Needed by freeze_importlib. */ 
-    int _install_importlib; 
- 
-    /* If equal to 0, stop Python initialization before the "main" phase */ 
-    int _init_main; 
- 
-    /* If non-zero, disallow threads, subprocesses, and fork. 
-       Default: 0. */ 
-    int _isolated_interpreter; 
- 
-    /* Original command line arguments. If _orig_argv is empty and _argv is 
-       not equal to [''], PyConfig_Read() copies the configuration 'argv' list 
-       into '_orig_argv' list before modifying 'argv' list (if parse_argv 
-       is non-zero). 
- 
-       _PyConfig_Write() initializes Py_GetArgcArgv() to this list. */ 
-    PyWideStringList _orig_argv; 
-} PyConfig; 
- 
-PyAPI_FUNC(void) PyConfig_InitPythonConfig(PyConfig *config); 
-PyAPI_FUNC(void) PyConfig_InitIsolatedConfig(PyConfig *config); 
-PyAPI_FUNC(void) PyConfig_Clear(PyConfig *); 
-PyAPI_FUNC(PyStatus) PyConfig_SetString( 
-    PyConfig *config, 
-    wchar_t **config_str, 
-    const wchar_t *str); 
-PyAPI_FUNC(PyStatus) PyConfig_SetBytesString( 
-    PyConfig *config, 
-    wchar_t **config_str, 
-    const char *str); 
-PyAPI_FUNC(PyStatus) PyConfig_Read(PyConfig *config); 
-PyAPI_FUNC(PyStatus) PyConfig_SetBytesArgv( 
-    PyConfig *config, 
-    Py_ssize_t argc, 
-    char * const *argv); 
-PyAPI_FUNC(PyStatus) PyConfig_SetArgv(PyConfig *config, 
-    Py_ssize_t argc, 
-    wchar_t * const *argv); 
-PyAPI_FUNC(PyStatus) PyConfig_SetWideStringList(PyConfig *config, 
-    PyWideStringList *list, 
-    Py_ssize_t length, wchar_t **items); 
- 
- 
-/* --- Helper functions --------------------------------------- */ 
- 
-/* Get the original command line arguments, before Python modified them. 
- 
-   See also PyConfig._orig_argv. */ 
-PyAPI_FUNC(void) Py_GetArgcArgv(int *argc, wchar_t ***argv); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
-#endif /* !Py_LIMITED_API */ 
-#endif /* !Py_PYCORECONFIG_H */ 
+#ifndef Py_PYCORECONFIG_H
+#define Py_PYCORECONFIG_H
+#ifndef Py_LIMITED_API
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* --- PyStatus ----------------------------------------------- */
+
+typedef struct {
+    enum {
+        _PyStatus_TYPE_OK=0,
+        _PyStatus_TYPE_ERROR=1,
+        _PyStatus_TYPE_EXIT=2
+    } _type;
+    const char *func;
+    const char *err_msg;
+    int exitcode;
+} PyStatus;
+
+PyAPI_FUNC(PyStatus) PyStatus_Ok(void);
+PyAPI_FUNC(PyStatus) PyStatus_Error(const char *err_msg);
+PyAPI_FUNC(PyStatus) PyStatus_NoMemory(void);
+PyAPI_FUNC(PyStatus) PyStatus_Exit(int exitcode);
+PyAPI_FUNC(int) PyStatus_IsError(PyStatus err);
+PyAPI_FUNC(int) PyStatus_IsExit(PyStatus err);
+PyAPI_FUNC(int) PyStatus_Exception(PyStatus err);
+
+/* --- PyWideStringList ------------------------------------------------ */
+
+typedef struct {
+    /* If length is greater than zero, items must be non-NULL
+       and all items strings must be non-NULL */
+    Py_ssize_t length;
+    wchar_t **items;
+} PyWideStringList;
+
+PyAPI_FUNC(PyStatus) PyWideStringList_Append(PyWideStringList *list,
+    const wchar_t *item);
+PyAPI_FUNC(PyStatus) PyWideStringList_Insert(PyWideStringList *list,
+    Py_ssize_t index,
+    const wchar_t *item);
+
+
+/* --- PyPreConfig ----------------------------------------------- */
+
+typedef struct {
+    int _config_init;     /* _PyConfigInitEnum value */
+
+    /* Parse Py_PreInitializeFromBytesArgs() arguments?
+       See PyConfig.parse_argv */
+    int parse_argv;
+
+    /* If greater than 0, enable isolated mode: sys.path contains
+       neither the script's directory nor the user's site-packages directory.
+
+       Set to 1 by the -I command line option. If set to -1 (default), inherit
+       Py_IsolatedFlag value. */
+    int isolated;
+
+    /* If greater than 0: use environment variables.
+       Set to 0 by -E command line option. If set to -1 (default), it is
+       set to !Py_IgnoreEnvironmentFlag. */
+    int use_environment;
+
+    /* Set the LC_CTYPE locale to the user preferred locale? If equals to 0,
+       set coerce_c_locale and coerce_c_locale_warn to 0. */
+    int configure_locale;
+
+    /* Coerce the LC_CTYPE locale if it's equal to "C"? (PEP 538)
+
+       Set to 0 by PYTHONCOERCECLOCALE=0. Set to 1 by PYTHONCOERCECLOCALE=1.
+       Set to 2 if the user preferred LC_CTYPE locale is "C".
+
+       If it is equal to 1, LC_CTYPE locale is read to decide if it should be
+       coerced or not (ex: PYTHONCOERCECLOCALE=1). Internally, it is set to 2
+       if the LC_CTYPE locale must be coerced.
+
+       Disable by default (set to 0). Set it to -1 to let Python decide if it
+       should be enabled or not. */
+    int coerce_c_locale;
+
+    /* Emit a warning if the LC_CTYPE locale is coerced?
+
+       Set to 1 by PYTHONCOERCECLOCALE=warn.
+
+       Disable by default (set to 0). Set it to -1 to let Python decide if it
+       should be enabled or not. */
+    int coerce_c_locale_warn;
+
+#ifdef MS_WINDOWS
+    /* If greater than 1, use the "mbcs" encoding instead of the UTF-8
+       encoding for the filesystem encoding.
+
+       Set to 1 if the PYTHONLEGACYWINDOWSFSENCODING environment variable is
+       set to a non-empty string. If set to -1 (default), inherit
+       Py_LegacyWindowsFSEncodingFlag value.
+
+       See PEP 529 for more details. */
+    int legacy_windows_fs_encoding;
+#endif
+
+    /* Enable UTF-8 mode? (PEP 540)
+
+       Disabled by default (equals to 0).
+
+       Set to 1 by "-X utf8" and "-X utf8=1" command line options.
+       Set to 1 by PYTHONUTF8=1 environment variable.
+
+       Set to 0 by "-X utf8=0" and PYTHONUTF8=0.
+
+       If equals to -1, it is set to 1 if the LC_CTYPE locale is "C" or
+       "POSIX", otherwise it is set to 0. Inherit Py_UTF8Mode value value. */
+    int utf8_mode;
+
+    /* If non-zero, enable the Python Development Mode.
+
+       Set to 1 by the -X dev command line option. Set by the PYTHONDEVMODE
+       environment variable. */
+    int dev_mode;
+
+    /* Memory allocator: PYTHONMALLOC env var.
+       See PyMemAllocatorName for valid values. */
+    int allocator;
+} PyPreConfig;
+
+PyAPI_FUNC(void) PyPreConfig_InitPythonConfig(PyPreConfig *config);
+PyAPI_FUNC(void) PyPreConfig_InitIsolatedConfig(PyPreConfig *config);
+
+
+/* --- PyConfig ---------------------------------------------- */
+
+typedef struct {
+    int _config_init;     /* _PyConfigInitEnum value */
+
+    int isolated;         /* Isolated mode? see PyPreConfig.isolated */
+    int use_environment;  /* Use environment variables? see PyPreConfig.use_environment */
+    int dev_mode;         /* Python Development Mode? See PyPreConfig.dev_mode */
+
+    /* Install signal handlers? Yes by default. */
+    int install_signal_handlers;
+
+    int use_hash_seed;      /* PYTHONHASHSEED=x */
+    unsigned long hash_seed;
+
+    /* Enable faulthandler?
+       Set to 1 by -X faulthandler and PYTHONFAULTHANDLER. -1 means unset. */
+    int faulthandler;
+
+    /* Enable PEG parser?
+       1 by default, set to 0 by -X oldparser and PYTHONOLDPARSER */
+    int _use_peg_parser;
+
+    /* Enable tracemalloc?
+       Set by -X tracemalloc=N and PYTHONTRACEMALLOC. -1 means unset */
+    int tracemalloc;
+
+    int import_time;        /* PYTHONPROFILEIMPORTTIME, -X importtime */
+    int show_ref_count;     /* -X showrefcount */
+    int dump_refs;          /* PYTHONDUMPREFS */
+    int malloc_stats;       /* PYTHONMALLOCSTATS */
+
+    /* Python filesystem encoding and error handler:
+       sys.getfilesystemencoding() and sys.getfilesystemencodeerrors().
+
+       Default encoding and error handler:
+
+       * if Py_SetStandardStreamEncoding() has been called: they have the
+         highest priority;
+       * PYTHONIOENCODING environment variable;
+       * The UTF-8 Mode uses UTF-8/surrogateescape;
+       * If Python forces the usage of the ASCII encoding (ex: C locale
+         or POSIX locale on FreeBSD or HP-UX), use ASCII/surrogateescape;
+       * locale encoding: ANSI code page on Windows, UTF-8 on Android and
+         VxWorks, LC_CTYPE locale encoding on other platforms;
+       * On Windows, "surrogateescape" error handler;
+       * "surrogateescape" error handler if the LC_CTYPE locale is "C" or "POSIX";
+       * "surrogateescape" error handler if the LC_CTYPE locale has been coerced
+         (PEP 538);
+       * "strict" error handler.
+
+       Supported error handlers: "strict", "surrogateescape" and
+       "surrogatepass". The surrogatepass error handler is only supported
+       if Py_DecodeLocale() and Py_EncodeLocale() use directly the UTF-8 codec;
+       it's only used on Windows.
+
+       initfsencoding() updates the encoding to the Python codec name.
+       For example, "ANSI_X3.4-1968" is replaced with "ascii".
+
+       On Windows, sys._enablelegacywindowsfsencoding() sets the
+       encoding/errors to mbcs/replace at runtime.
+
+
+       See Py_FileSystemDefaultEncoding and Py_FileSystemDefaultEncodeErrors.
+       */
+    wchar_t *filesystem_encoding;
+    wchar_t *filesystem_errors;
+
+    wchar_t *pycache_prefix;  /* PYTHONPYCACHEPREFIX, -X pycache_prefix=PATH */
+    int parse_argv;           /* Parse argv command line arguments? */
+
+    /* Command line arguments (sys.argv).
+
+       Set parse_argv to 1 to parse argv as Python command line arguments
+       and then strip Python arguments from argv.
+
+       If argv is empty, an empty string is added to ensure that sys.argv
+       always exists and is never empty. */
+    PyWideStringList argv;
+
+    /* Program name:
+
+       - If Py_SetProgramName() was called, use its value.
+       - On macOS, use PYTHONEXECUTABLE environment variable if set.
+       - If WITH_NEXT_FRAMEWORK macro is defined, use __PYVENV_LAUNCHER__
+         environment variable is set.
+       - Use argv[0] if available and non-empty.
+       - Use "python" on Windows, or "python3 on other platforms. */
+    wchar_t *program_name;
+
+    PyWideStringList xoptions;     /* Command line -X options */
+
+    /* Warnings options: lowest to highest priority. warnings.filters
+       is built in the reverse order (highest to lowest priority). */
+    PyWideStringList warnoptions;
+
+    /* If equal to zero, disable the import of the module site and the
+       site-dependent manipulations of sys.path that it entails. Also disable
+       these manipulations if site is explicitly imported later (call
+       site.main() if you want them to be triggered).
+
+       Set to 0 by the -S command line option. If set to -1 (default), it is
+       set to !Py_NoSiteFlag. */
+    int site_import;
+
+    /* Bytes warnings:
+
+       * If equal to 1, issue a warning when comparing bytes or bytearray with
+         str or bytes with int.
+       * If equal or greater to 2, issue an error.
+
+       Incremented by the -b command line option. If set to -1 (default), inherit
+       Py_BytesWarningFlag value. */
+    int bytes_warning;
+
+    /* If greater than 0, enable inspect: when a script is passed as first
+       argument or the -c option is used, enter interactive mode after
+       executing the script or the command, even when sys.stdin does not appear
+       to be a terminal.
+
+       Incremented by the -i command line option. Set to 1 if the PYTHONINSPECT
+       environment variable is non-empty. If set to -1 (default), inherit
+       Py_InspectFlag value. */
+    int inspect;
+
+    /* If greater than 0: enable the interactive mode (REPL).
+
+       Incremented by the -i command line option. If set to -1 (default),
+       inherit Py_InteractiveFlag value. */
+    int interactive;
+
+    /* Optimization level.
+
+       Incremented by the -O command line option. Set by the PYTHONOPTIMIZE
+       environment variable. If set to -1 (default), inherit Py_OptimizeFlag
+       value. */
+    int optimization_level;
+
+    /* If greater than 0, enable the debug mode: turn on parser debugging
+       output (for expert only, depending on compilation options).
+
+       Incremented by the -d command line option. Set by the PYTHONDEBUG
+       environment variable. If set to -1 (default), inherit Py_DebugFlag
+       value. */
+    int parser_debug;
+
+    /* If equal to 0, Python won't try to write ``.pyc`` files on the
+       import of source modules.
+
+       Set to 0 by the -B command line option and the PYTHONDONTWRITEBYTECODE
+       environment variable. If set to -1 (default), it is set to
+       !Py_DontWriteBytecodeFlag. */
+    int write_bytecode;
+
+    /* If greater than 0, enable the verbose mode: print a message each time a
+       module is initialized, showing the place (filename or built-in module)
+       from which it is loaded.
+
+       If greater or equal to 2, print a message for each file that is checked
+       for when searching for a module. Also provides information on module
+       cleanup at exit.
+
+       Incremented by the -v option. Set by the PYTHONVERBOSE environment
+       variable. If set to -1 (default), inherit Py_VerboseFlag value. */
+    int verbose;
+
+    /* If greater than 0, enable the quiet mode: Don't display the copyright
+       and version messages even in interactive mode.
+
+       Incremented by the -q option. If set to -1 (default), inherit
+       Py_QuietFlag value. */
+    int quiet;
+
+   /* If greater than 0, don't add the user site-packages directory to
+      sys.path.
+
+      Set to 0 by the -s and -I command line options , and the PYTHONNOUSERSITE
+      environment variable. If set to -1 (default), it is set to
+      !Py_NoUserSiteDirectory. */
+    int user_site_directory;
+
+    /* If non-zero, configure C standard steams (stdio, stdout,
+       stderr):
+
+       - Set O_BINARY mode on Windows.
+       - If buffered_stdio is equal to zero, make streams unbuffered.
+         Otherwise, enable streams buffering if interactive is non-zero. */
+    int configure_c_stdio;
+
+    /* If equal to 0, enable unbuffered mode: force the stdout and stderr
+       streams to be unbuffered.
+
+       Set to 0 by the -u option. Set by the PYTHONUNBUFFERED environment
+       variable.
+       If set to -1 (default), it is set to !Py_UnbufferedStdioFlag. */
+    int buffered_stdio;
+
+    /* Encoding of sys.stdin, sys.stdout and sys.stderr.
+       Value set from PYTHONIOENCODING environment variable and
+       Py_SetStandardStreamEncoding() function.
+       See also 'stdio_errors' attribute. */
+    wchar_t *stdio_encoding;
+
+    /* Error handler of sys.stdin and sys.stdout.
+       Value set from PYTHONIOENCODING environment variable and
+       Py_SetStandardStreamEncoding() function.
+       See also 'stdio_encoding' attribute. */
+    wchar_t *stdio_errors;
+
+#ifdef MS_WINDOWS
+    /* If greater than zero, use io.FileIO instead of WindowsConsoleIO for sys
+       standard streams.
+
+       Set to 1 if the PYTHONLEGACYWINDOWSSTDIO environment variable is set to
+       a non-empty string. If set to -1 (default), inherit
+       Py_LegacyWindowsStdioFlag value.
+
+       See PEP 528 for more details. */
+    int legacy_windows_stdio;
+#endif
+
+    /* Value of the --check-hash-based-pycs command line option:
+
+       - "default" means the 'check_source' flag in hash-based pycs
+         determines invalidation
+       - "always" causes the interpreter to hash the source file for
+         invalidation regardless of value of 'check_source' bit
+       - "never" causes the interpreter to always assume hash-based pycs are
+         valid
+
+       The default value is "default".
+
+       See PEP 552 "Deterministic pycs" for more details. */
+    wchar_t *check_hash_pycs_mode;
+
+    /* --- Path configuration inputs ------------ */
+
+    /* If greater than 0, suppress _PyPathConfig_Calculate() warnings on Unix.
+       The parameter has no effect on Windows.
+
+       If set to -1 (default), inherit !Py_FrozenFlag value. */
+    int pathconfig_warnings;
+
+    wchar_t *pythonpath_env; /* PYTHONPATH environment variable */
+    wchar_t *home;          /* PYTHONHOME environment variable,
+                               see also Py_SetPythonHome(). */
+
+    /* --- Path configuration outputs ----------- */
+
+    int module_search_paths_set;  /* If non-zero, use module_search_paths */
+    PyWideStringList module_search_paths;  /* sys.path paths. Computed if
+                                       module_search_paths_set is equal
+                                       to zero. */
+
+    wchar_t *executable;        /* sys.executable */
+    wchar_t *base_executable;   /* sys._base_executable */
+    wchar_t *prefix;            /* sys.prefix */
+    wchar_t *base_prefix;       /* sys.base_prefix */
+    wchar_t *exec_prefix;       /* sys.exec_prefix */
+    wchar_t *base_exec_prefix;  /* sys.base_exec_prefix */
+    wchar_t *platlibdir;        /* sys.platlibdir */
+
+    /* --- Parameter only used by Py_Main() ---------- */
+
+    /* Skip the first line of the source ('run_filename' parameter), allowing use of non-Unix forms of
+       "#!cmd".  This is intended for a DOS specific hack only.
+
+       Set by the -x command line option. */
+    int skip_source_first_line;
+
+    wchar_t *run_command;   /* -c command line argument */
+    wchar_t *run_module;    /* -m command line argument */
+    wchar_t *run_filename;  /* Trailing command line argument without -c or -m */
+
+    /* --- Private fields ---------------------------- */
+
+    /* Install importlib? If set to 0, importlib is not initialized at all.
+       Needed by freeze_importlib. */
+    int _install_importlib;
+
+    /* If equal to 0, stop Python initialization before the "main" phase */
+    int _init_main;
+
+    /* If non-zero, disallow threads, subprocesses, and fork.
+       Default: 0. */
+    int _isolated_interpreter;
+
+    /* Original command line arguments. If _orig_argv is empty and _argv is
+       not equal to [''], PyConfig_Read() copies the configuration 'argv' list
+       into '_orig_argv' list before modifying 'argv' list (if parse_argv
+       is non-zero).
+
+       _PyConfig_Write() initializes Py_GetArgcArgv() to this list. */
+    PyWideStringList _orig_argv;
+} PyConfig;
+
+PyAPI_FUNC(void) PyConfig_InitPythonConfig(PyConfig *config);
+PyAPI_FUNC(void) PyConfig_InitIsolatedConfig(PyConfig *config);
+PyAPI_FUNC(void) PyConfig_Clear(PyConfig *);
+PyAPI_FUNC(PyStatus) PyConfig_SetString(
+    PyConfig *config,
+    wchar_t **config_str,
+    const wchar_t *str);
+PyAPI_FUNC(PyStatus) PyConfig_SetBytesString(
+    PyConfig *config,
+    wchar_t **config_str,
+    const char *str);
+PyAPI_FUNC(PyStatus) PyConfig_Read(PyConfig *config);
+PyAPI_FUNC(PyStatus) PyConfig_SetBytesArgv(
+    PyConfig *config,
+    Py_ssize_t argc,
+    char * const *argv);
+PyAPI_FUNC(PyStatus) PyConfig_SetArgv(PyConfig *config,
+    Py_ssize_t argc,
+    wchar_t * const *argv);
+PyAPI_FUNC(PyStatus) PyConfig_SetWideStringList(PyConfig *config,
+    PyWideStringList *list,
+    Py_ssize_t length, wchar_t **items);
+
+
+/* --- Helper functions --------------------------------------- */
+
+/* Get the original command line arguments, before Python modified them.
+
+   See also PyConfig._orig_argv. */
+PyAPI_FUNC(void) Py_GetArgcArgv(int *argc, wchar_t ***argv);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_LIMITED_API */
+#endif /* !Py_PYCORECONFIG_H */
diff --git a/contrib/tools/python3/src/Include/cpython/interpreteridobject.h b/contrib/tools/python3/src/Include/cpython/interpreteridobject.h
index a92a6545e4..67ec587354 100644
--- a/contrib/tools/python3/src/Include/cpython/interpreteridobject.h
+++ b/contrib/tools/python3/src/Include/cpython/interpreteridobject.h
@@ -1,19 +1,19 @@
-#ifndef Py_CPYTHON_INTERPRETERIDOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-/* Interpreter ID Object */ 
- 
-PyAPI_DATA(PyTypeObject) _PyInterpreterID_Type; 
- 
-PyAPI_FUNC(PyObject *) _PyInterpreterID_New(int64_t); 
-PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *); 
-PyAPI_FUNC(PyInterpreterState *) _PyInterpreterID_LookUp(PyObject *); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_INTERPRETERIDOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Interpreter ID Object */
+
+PyAPI_DATA(PyTypeObject) _PyInterpreterID_Type;
+
+PyAPI_FUNC(PyObject *) _PyInterpreterID_New(int64_t);
+PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *);
+PyAPI_FUNC(PyInterpreterState *) _PyInterpreterID_LookUp(PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/listobject.h b/contrib/tools/python3/src/Include/cpython/listobject.h
index b405b140a5..74fe3301a7 100644
--- a/contrib/tools/python3/src/Include/cpython/listobject.h
+++ b/contrib/tools/python3/src/Include/cpython/listobject.h
@@ -1,43 +1,43 @@
-#ifndef Py_CPYTHON_LISTOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-typedef struct { 
-    PyObject_VAR_HEAD 
-    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */ 
-    PyObject **ob_item; 
- 
-    /* ob_item contains space for 'allocated' elements.  The number 
-     * currently in use is ob_size. 
-     * Invariants: 
-     *     0 <= ob_size <= allocated 
-     *     len(list) == ob_size 
-     *     ob_item == NULL implies ob_size == allocated == 0 
-     * list.sort() temporarily sets allocated to -1 to detect mutations. 
-     * 
-     * Items must normally not be NULL, except during construction when 
-     * the list is not yet visible outside the function that builds it. 
-     */ 
-    Py_ssize_t allocated; 
-} PyListObject; 
- 
-PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *); 
-PyAPI_FUNC(void) _PyList_DebugMallocStats(FILE *out); 
- 
-/* Macro, trading safety for speed */ 
- 
-/* Cast argument to PyTupleObject* type. */ 
-#define _PyList_CAST(op) (assert(PyList_Check(op)), (PyListObject *)(op)) 
- 
-#define PyList_GET_ITEM(op, i) (_PyList_CAST(op)->ob_item[i]) 
-#define PyList_SET_ITEM(op, i, v) (_PyList_CAST(op)->ob_item[i] = (v)) 
-#define PyList_GET_SIZE(op)    Py_SIZE(_PyList_CAST(op)) 
-#define _PyList_ITEMS(op)      (_PyList_CAST(op)->ob_item) 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_LISTOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_VAR_HEAD
+    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
+    PyObject **ob_item;
+
+    /* ob_item contains space for 'allocated' elements.  The number
+     * currently in use is ob_size.
+     * Invariants:
+     *     0 <= ob_size <= allocated
+     *     len(list) == ob_size
+     *     ob_item == NULL implies ob_size == allocated == 0
+     * list.sort() temporarily sets allocated to -1 to detect mutations.
+     *
+     * Items must normally not be NULL, except during construction when
+     * the list is not yet visible outside the function that builds it.
+     */
+    Py_ssize_t allocated;
+} PyListObject;
+
+PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *);
+PyAPI_FUNC(void) _PyList_DebugMallocStats(FILE *out);
+
+/* Macro, trading safety for speed */
+
+/* Cast argument to PyTupleObject* type. */
+#define _PyList_CAST(op) (assert(PyList_Check(op)), (PyListObject *)(op))
+
+#define PyList_GET_ITEM(op, i) (_PyList_CAST(op)->ob_item[i])
+#define PyList_SET_ITEM(op, i, v) (_PyList_CAST(op)->ob_item[i] = (v))
+#define PyList_GET_SIZE(op)    Py_SIZE(_PyList_CAST(op))
+#define _PyList_ITEMS(op)      (_PyList_CAST(op)->ob_item)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/methodobject.h b/contrib/tools/python3/src/Include/cpython/methodobject.h
index f23dca0c6f..7ecbfe3b5e 100644
--- a/contrib/tools/python3/src/Include/cpython/methodobject.h
+++ b/contrib/tools/python3/src/Include/cpython/methodobject.h
@@ -1,35 +1,35 @@
-#ifndef Py_CPYTHON_METHODOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-PyAPI_DATA(PyTypeObject) PyCMethod_Type; 
- 
-#define PyCMethod_CheckExact(op) Py_IS_TYPE(op, &PyCMethod_Type) 
-#define PyCMethod_Check(op) PyObject_TypeCheck(op, &PyCMethod_Type) 
- 
-/* Macros for direct access to these values. Type checks are *not* 
-   done, so use with care. */ 
-#define PyCFunction_GET_FUNCTION(func) \ 
-        (((PyCFunctionObject *)func) -> m_ml -> ml_meth) 
-#define PyCFunction_GET_SELF(func) \ 
-        (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_STATIC ? \ 
-         NULL : ((PyCFunctionObject *)func) -> m_self) 
-#define PyCFunction_GET_FLAGS(func) \ 
-        (((PyCFunctionObject *)func) -> m_ml -> ml_flags) 
-#define PyCFunction_GET_CLASS(func) \ 
-    (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_METHOD ? \ 
-         ((PyCMethodObject *)func) -> mm_class : NULL) 
- 
-typedef struct { 
-    PyObject_HEAD 
-    PyMethodDef *m_ml; /* Description of the C function to call */ 
-    PyObject    *m_self; /* Passed as 'self' arg to the C func, can be NULL */ 
-    PyObject    *m_module; /* The __module__ attribute, can be anything */ 
-    PyObject    *m_weakreflist; /* List of weak references */ 
-    vectorcallfunc vectorcall; 
-} PyCFunctionObject; 
- 
-typedef struct { 
-    PyCFunctionObject func; 
-    PyTypeObject *mm_class; /* Class that defines this method */ 
-} PyCMethodObject; 
+#ifndef Py_CPYTHON_METHODOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+PyAPI_DATA(PyTypeObject) PyCMethod_Type;
+
+#define PyCMethod_CheckExact(op) Py_IS_TYPE(op, &PyCMethod_Type)
+#define PyCMethod_Check(op) PyObject_TypeCheck(op, &PyCMethod_Type)
+
+/* Macros for direct access to these values. Type checks are *not*
+   done, so use with care. */
+#define PyCFunction_GET_FUNCTION(func) \
+        (((PyCFunctionObject *)func) -> m_ml -> ml_meth)
+#define PyCFunction_GET_SELF(func) \
+        (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_STATIC ? \
+         NULL : ((PyCFunctionObject *)func) -> m_self)
+#define PyCFunction_GET_FLAGS(func) \
+        (((PyCFunctionObject *)func) -> m_ml -> ml_flags)
+#define PyCFunction_GET_CLASS(func) \
+    (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_METHOD ? \
+         ((PyCMethodObject *)func) -> mm_class : NULL)
+
+typedef struct {
+    PyObject_HEAD
+    PyMethodDef *m_ml; /* Description of the C function to call */
+    PyObject    *m_self; /* Passed as 'self' arg to the C func, can be NULL */
+    PyObject    *m_module; /* The __module__ attribute, can be anything */
+    PyObject    *m_weakreflist; /* List of weak references */
+    vectorcallfunc vectorcall;
+} PyCFunctionObject;
+
+typedef struct {
+    PyCFunctionObject func;
+    PyTypeObject *mm_class; /* Class that defines this method */
+} PyCMethodObject;
diff --git a/contrib/tools/python3/src/Include/cpython/object.h b/contrib/tools/python3/src/Include/cpython/object.h
index 6327414667..444f832f5b 100644
--- a/contrib/tools/python3/src/Include/cpython/object.h
+++ b/contrib/tools/python3/src/Include/cpython/object.h
@@ -1,554 +1,554 @@
-#ifndef Py_CPYTHON_OBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-PyAPI_FUNC(void) _Py_NewReference(PyObject *op); 
- 
-#ifdef Py_TRACE_REFS 
-/* Py_TRACE_REFS is such major surgery that we call external routines. */ 
-PyAPI_FUNC(void) _Py_ForgetReference(PyObject *); 
-#endif 
- 
-/* Update the Python traceback of an object. This function must be called 
-   when a memory block is reused from a free list. */ 
-PyAPI_FUNC(int) _PyTraceMalloc_NewReference(PyObject *op); 
- 
-#ifdef Py_REF_DEBUG 
-PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void); 
-#endif 
- 
- 
-/********************* String Literals ****************************************/ 
-/* This structure helps managing static strings. The basic usage goes like this: 
-   Instead of doing 
- 
-       r = PyObject_CallMethod(o, "foo", "args", ...); 
- 
-   do 
- 
-       _Py_IDENTIFIER(foo); 
-       ... 
-       r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...); 
- 
-   PyId_foo is a static variable, either on block level or file level. On first 
-   usage, the string "foo" is interned, and the structures are linked. On interpreter 
-   shutdown, all strings are released. 
- 
-   Alternatively, _Py_static_string allows choosing the variable name. 
-   _PyUnicode_FromId returns a borrowed reference to the interned string. 
-   _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*. 
-*/ 
-typedef struct _Py_Identifier { 
-    struct _Py_Identifier *next; 
-    const char* string; 
-    PyObject *object; 
-} _Py_Identifier; 
- 
-#define _Py_static_string_init(value) { .next = NULL, .string = value, .object = NULL } 
-#define _Py_static_string(varname, value)  static _Py_Identifier varname = _Py_static_string_init(value) 
-#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname) 
- 
-/* buffer interface */ 
-typedef struct bufferinfo { 
-    void *buf; 
-    PyObject *obj;        /* owned reference */ 
-    Py_ssize_t len; 
-    Py_ssize_t itemsize;  /* This is Py_ssize_t so it can be 
-                             pointed to by strides in simple case.*/ 
-    int readonly; 
-    int ndim; 
-    char *format; 
-    Py_ssize_t *shape; 
-    Py_ssize_t *strides; 
-    Py_ssize_t *suboffsets; 
-    void *internal; 
-} Py_buffer; 
- 
-typedef int (*getbufferproc)(PyObject *, Py_buffer *, int); 
-typedef void (*releasebufferproc)(PyObject *, Py_buffer *); 
- 
-typedef PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args, 
-                                    size_t nargsf, PyObject *kwnames); 
- 
-/* Maximum number of dimensions */ 
-#define PyBUF_MAX_NDIM 64 
- 
-/* Flags for getting buffers */ 
-#define PyBUF_SIMPLE 0 
-#define PyBUF_WRITABLE 0x0001 
-/*  we used to include an E, backwards compatible alias  */ 
-#define PyBUF_WRITEABLE PyBUF_WRITABLE 
-#define PyBUF_FORMAT 0x0004 
-#define PyBUF_ND 0x0008 
-#define PyBUF_STRIDES (0x0010 | PyBUF_ND) 
-#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES) 
-#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES) 
-#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES) 
-#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES) 
- 
-#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE) 
-#define PyBUF_CONTIG_RO (PyBUF_ND) 
- 
-#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE) 
-#define PyBUF_STRIDED_RO (PyBUF_STRIDES) 
- 
-#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT) 
-#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT) 
- 
-#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT) 
-#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT) 
- 
- 
-#define PyBUF_READ  0x100 
-#define PyBUF_WRITE 0x200 
-/* End buffer interface */ 
- 
- 
-typedef struct { 
-    /* Number implementations must check *both* 
-       arguments for proper type and implement the necessary conversions 
-       in the slot functions themselves. */ 
- 
-    binaryfunc nb_add; 
-    binaryfunc nb_subtract; 
-    binaryfunc nb_multiply; 
-    binaryfunc nb_remainder; 
-    binaryfunc nb_divmod; 
-    ternaryfunc nb_power; 
-    unaryfunc nb_negative; 
-    unaryfunc nb_positive; 
-    unaryfunc nb_absolute; 
-    inquiry nb_bool; 
-    unaryfunc nb_invert; 
-    binaryfunc nb_lshift; 
-    binaryfunc nb_rshift; 
-    binaryfunc nb_and; 
-    binaryfunc nb_xor; 
-    binaryfunc nb_or; 
-    unaryfunc nb_int; 
-    void *nb_reserved;  /* the slot formerly known as nb_long */ 
-    unaryfunc nb_float; 
- 
-    binaryfunc nb_inplace_add; 
-    binaryfunc nb_inplace_subtract; 
-    binaryfunc nb_inplace_multiply; 
-    binaryfunc nb_inplace_remainder; 
-    ternaryfunc nb_inplace_power; 
-    binaryfunc nb_inplace_lshift; 
-    binaryfunc nb_inplace_rshift; 
-    binaryfunc nb_inplace_and; 
-    binaryfunc nb_inplace_xor; 
-    binaryfunc nb_inplace_or; 
- 
-    binaryfunc nb_floor_divide; 
-    binaryfunc nb_true_divide; 
-    binaryfunc nb_inplace_floor_divide; 
-    binaryfunc nb_inplace_true_divide; 
- 
-    unaryfunc nb_index; 
- 
-    binaryfunc nb_matrix_multiply; 
-    binaryfunc nb_inplace_matrix_multiply; 
-} PyNumberMethods; 
- 
-typedef struct { 
-    lenfunc sq_length; 
-    binaryfunc sq_concat; 
-    ssizeargfunc sq_repeat; 
-    ssizeargfunc sq_item; 
-    void *was_sq_slice; 
-    ssizeobjargproc sq_ass_item; 
-    void *was_sq_ass_slice; 
-    objobjproc sq_contains; 
- 
-    binaryfunc sq_inplace_concat; 
-    ssizeargfunc sq_inplace_repeat; 
-} PySequenceMethods; 
- 
-typedef struct { 
-    lenfunc mp_length; 
-    binaryfunc mp_subscript; 
-    objobjargproc mp_ass_subscript; 
-} PyMappingMethods; 
- 
-typedef struct { 
-    unaryfunc am_await; 
-    unaryfunc am_aiter; 
-    unaryfunc am_anext; 
-} PyAsyncMethods; 
- 
-typedef struct { 
-     getbufferproc bf_getbuffer; 
-     releasebufferproc bf_releasebuffer; 
-} PyBufferProcs; 
- 
-/* Allow printfunc in the tp_vectorcall_offset slot for 
- * backwards-compatibility */ 
-typedef Py_ssize_t printfunc; 
- 
-struct _typeobject { 
-    PyObject_VAR_HEAD 
-    const char *tp_name; /* For printing, in format "<module>.<name>" */ 
-    Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */ 
- 
-    /* Methods to implement standard operations */ 
- 
-    destructor tp_dealloc; 
-    Py_ssize_t tp_vectorcall_offset; 
-    getattrfunc tp_getattr; 
-    setattrfunc tp_setattr; 
-    PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2) 
-                                    or tp_reserved (Python 3) */ 
-    reprfunc tp_repr; 
- 
-    /* Method suites for standard classes */ 
- 
-    PyNumberMethods *tp_as_number; 
-    PySequenceMethods *tp_as_sequence; 
-    PyMappingMethods *tp_as_mapping; 
- 
-    /* More standard operations (here for binary compatibility) */ 
- 
-    hashfunc tp_hash; 
-    ternaryfunc tp_call; 
-    reprfunc tp_str; 
-    getattrofunc tp_getattro; 
-    setattrofunc tp_setattro; 
- 
-    /* Functions to access object as input/output buffer */ 
-    PyBufferProcs *tp_as_buffer; 
- 
-    /* Flags to define presence of optional/expanded features */ 
-    unsigned long tp_flags; 
- 
-    const char *tp_doc; /* Documentation string */ 
- 
-    /* Assigned meaning in release 2.0 */ 
-    /* call function for all accessible objects */ 
-    traverseproc tp_traverse; 
- 
-    /* delete references to contained objects */ 
-    inquiry tp_clear; 
- 
-    /* Assigned meaning in release 2.1 */ 
-    /* rich comparisons */ 
-    richcmpfunc tp_richcompare; 
- 
-    /* weak reference enabler */ 
-    Py_ssize_t tp_weaklistoffset; 
- 
-    /* Iterators */ 
-    getiterfunc tp_iter; 
-    iternextfunc tp_iternext; 
- 
-    /* Attribute descriptor and subclassing stuff */ 
-    struct PyMethodDef *tp_methods; 
-    struct PyMemberDef *tp_members; 
-    struct PyGetSetDef *tp_getset; 
-    struct _typeobject *tp_base; 
-    PyObject *tp_dict; 
-    descrgetfunc tp_descr_get; 
-    descrsetfunc tp_descr_set; 
-    Py_ssize_t tp_dictoffset; 
-    initproc tp_init; 
-    allocfunc tp_alloc; 
-    newfunc tp_new; 
-    freefunc tp_free; /* Low-level free-memory routine */ 
-    inquiry tp_is_gc; /* For PyObject_IS_GC */ 
-    PyObject *tp_bases; 
-    PyObject *tp_mro; /* method resolution order */ 
-    PyObject *tp_cache; 
-    PyObject *tp_subclasses; 
-    PyObject *tp_weaklist; 
-    destructor tp_del; 
- 
-    /* Type attribute cache version tag. Added in version 2.6 */ 
-    unsigned int tp_version_tag; 
- 
-    destructor tp_finalize; 
-    vectorcallfunc tp_vectorcall; 
-}; 
- 
-/* The *real* layout of a type object when allocated on the heap */ 
-typedef struct _heaptypeobject { 
-    /* Note: there's a dependency on the order of these members 
-       in slotptr() in typeobject.c . */ 
-    PyTypeObject ht_type; 
-    PyAsyncMethods as_async; 
-    PyNumberMethods as_number; 
-    PyMappingMethods as_mapping; 
-    PySequenceMethods as_sequence; /* as_sequence comes after as_mapping, 
-                                      so that the mapping wins when both 
-                                      the mapping and the sequence define 
-                                      a given operator (e.g. __getitem__). 
-                                      see add_operators() in typeobject.c . */ 
-    PyBufferProcs as_buffer; 
-    PyObject *ht_name, *ht_slots, *ht_qualname; 
-    struct _dictkeysobject *ht_cached_keys; 
-    PyObject *ht_module; 
-    /* here are optional user slots, followed by the members. */ 
-} PyHeapTypeObject; 
- 
-/* access macro to the members which are floating "behind" the object */ 
-#define PyHeapType_GET_MEMBERS(etype) \ 
-    ((PyMemberDef *)(((char *)etype) + Py_TYPE(etype)->tp_basicsize)) 
- 
-PyAPI_FUNC(const char *) _PyType_Name(PyTypeObject *); 
-PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *); 
-PyAPI_FUNC(PyObject *) _PyType_LookupId(PyTypeObject *, _Py_Identifier *); 
-PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, _Py_Identifier *); 
-PyAPI_FUNC(PyTypeObject *) _PyType_CalculateMetaclass(PyTypeObject *, PyObject *); 
-PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *); 
-PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *); 
- 
-struct _Py_Identifier; 
-PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int); 
-PyAPI_FUNC(void) _Py_BreakPoint(void); 
-PyAPI_FUNC(void) _PyObject_Dump(PyObject *); 
-PyAPI_FUNC(int) _PyObject_IsFreed(PyObject *); 
- 
-PyAPI_FUNC(int) _PyObject_IsAbstract(PyObject *); 
-PyAPI_FUNC(PyObject *) _PyObject_GetAttrId(PyObject *, struct _Py_Identifier *); 
-PyAPI_FUNC(int) _PyObject_SetAttrId(PyObject *, struct _Py_Identifier *, PyObject *); 
-PyAPI_FUNC(int) _PyObject_HasAttrId(PyObject *, struct _Py_Identifier *); 
-/* Replacements of PyObject_GetAttr() and _PyObject_GetAttrId() which 
-   don't raise AttributeError. 
- 
-   Return 1 and set *result != NULL if an attribute is found. 
-   Return 0 and set *result == NULL if an attribute is not found; 
-   an AttributeError is silenced. 
-   Return -1 and set *result == NULL if an error other than AttributeError 
-   is raised. 
-*/ 
-PyAPI_FUNC(int) _PyObject_LookupAttr(PyObject *, PyObject *, PyObject **); 
-PyAPI_FUNC(int) _PyObject_LookupAttrId(PyObject *, struct _Py_Identifier *, PyObject **); 
- 
-PyAPI_FUNC(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); 
- 
-PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *); 
-PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *); 
-PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *); 
-PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *); 
- 
-/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes 
-   dict as the last parameter. */ 
-PyAPI_FUNC(PyObject *) 
-_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *, int); 
-PyAPI_FUNC(int) 
-_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *, 
-                                 PyObject *, PyObject *); 
- 
-PyAPI_FUNC(PyObject *) _PyObject_FunctionStr(PyObject *); 
- 
-/* Safely decref `op` and set `op` to `op2`. 
- * 
- * As in case of Py_CLEAR "the obvious" code can be deadly: 
- * 
- *     Py_DECREF(op); 
- *     op = op2; 
- * 
- * The safe way is: 
- * 
- *      Py_SETREF(op, op2); 
- * 
- * That arranges to set `op` to `op2` _before_ decref'ing, so that any code 
- * triggered as a side-effect of `op` getting torn down no longer believes 
- * `op` points to a valid object. 
- * 
- * Py_XSETREF is a variant of Py_SETREF that uses Py_XDECREF instead of 
- * Py_DECREF. 
- */ 
- 
-#define Py_SETREF(op, op2)                      \ 
-    do {                                        \ 
-        PyObject *_py_tmp = _PyObject_CAST(op); \ 
-        (op) = (op2);                           \ 
-        Py_DECREF(_py_tmp);                     \ 
-    } while (0) 
- 
-#define Py_XSETREF(op, op2)                     \ 
-    do {                                        \ 
-        PyObject *_py_tmp = _PyObject_CAST(op); \ 
-        (op) = (op2);                           \ 
-        Py_XDECREF(_py_tmp);                    \ 
-    } while (0) 
- 
- 
-PyAPI_DATA(PyTypeObject) _PyNone_Type; 
-PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type; 
- 
-/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE. 
- * Defined in object.c. 
- */ 
-PyAPI_DATA(int) _Py_SwappedOp[]; 
- 
-PyAPI_FUNC(void) 
-_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks, 
-                       size_t sizeof_block); 
-PyAPI_FUNC(void) 
-_PyObject_DebugTypeStats(FILE *out); 
- 
-/* Define a pair of assertion macros: 
-   _PyObject_ASSERT_FROM(), _PyObject_ASSERT_WITH_MSG() and _PyObject_ASSERT(). 
- 
-   These work like the regular C assert(), in that they will abort the 
-   process with a message on stderr if the given condition fails to hold, 
-   but compile away to nothing if NDEBUG is defined. 
- 
-   However, before aborting, Python will also try to call _PyObject_Dump() on 
-   the given object.  This may be of use when investigating bugs in which a 
-   particular object is corrupt (e.g. buggy a tp_visit method in an extension 
-   module breaking the garbage collector), to help locate the broken objects. 
- 
-   The WITH_MSG variant allows you to supply an additional message that Python 
-   will attempt to print to stderr, after the object dump. */ 
-#ifdef NDEBUG 
-   /* No debugging: compile away the assertions: */ 
-#  define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \ 
-    ((void)0) 
-#else 
-   /* With debugging: generate checks: */ 
-#  define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \ 
-    ((expr) \ 
-      ? (void)(0) \ 
-      : _PyObject_AssertFailed((obj), Py_STRINGIFY(expr), \ 
-                               (msg), (filename), (lineno), (func))) 
-#endif 
- 
-#define _PyObject_ASSERT_WITH_MSG(obj, expr, msg) \ 
-    _PyObject_ASSERT_FROM(obj, expr, msg, __FILE__, __LINE__, __func__) 
-#define _PyObject_ASSERT(obj, expr) \ 
-    _PyObject_ASSERT_WITH_MSG(obj, expr, NULL) 
- 
-#define _PyObject_ASSERT_FAILED_MSG(obj, msg) \ 
-    _PyObject_AssertFailed((obj), NULL, (msg), __FILE__, __LINE__, __func__) 
- 
-/* Declare and define _PyObject_AssertFailed() even when NDEBUG is defined, 
-   to avoid causing compiler/linker errors when building extensions without 
-   NDEBUG against a Python built with NDEBUG defined. 
- 
-   msg, expr and function can be NULL. */ 
-PyAPI_FUNC(void) _Py_NO_RETURN _PyObject_AssertFailed( 
-    PyObject *obj, 
-    const char *expr, 
-    const char *msg, 
-    const char *file, 
-    int line, 
-    const char *function); 
- 
-/* Check if an object is consistent. For example, ensure that the reference 
-   counter is greater than or equal to 1, and ensure that ob_type is not NULL. 
- 
-   Call _PyObject_AssertFailed() if the object is inconsistent. 
- 
-   If check_content is zero, only check header fields: reduce the overhead. 
- 
-   The function always return 1. The return value is just here to be able to 
-   write: 
- 
-   assert(_PyObject_CheckConsistency(obj, 1)); */ 
-PyAPI_FUNC(int) _PyObject_CheckConsistency( 
-    PyObject *op, 
-    int check_content); 
- 
- 
-/* Trashcan mechanism, thanks to Christian Tismer. 
- 
-When deallocating a container object, it's possible to trigger an unbounded 
-chain of deallocations, as each Py_DECREF in turn drops the refcount on "the 
-next" object in the chain to 0.  This can easily lead to stack overflows, 
-especially in threads (which typically have less stack space to work with). 
- 
-A container object can avoid this by bracketing the body of its tp_dealloc 
-function with a pair of macros: 
- 
-static void 
-mytype_dealloc(mytype *p) 
-{ 
-    ... declarations go here ... 
- 
-    PyObject_GC_UnTrack(p);        // must untrack first 
-    Py_TRASHCAN_BEGIN(p, mytype_dealloc) 
-    ... The body of the deallocator goes here, including all calls ... 
-    ... to Py_DECREF on contained objects.                         ... 
-    Py_TRASHCAN_END                // there should be no code after this 
-} 
- 
-CAUTION:  Never return from the middle of the body!  If the body needs to 
-"get out early", put a label immediately before the Py_TRASHCAN_END 
-call, and goto it.  Else the call-depth counter (see below) will stay 
-above 0 forever, and the trashcan will never get emptied. 
- 
-How it works:  The BEGIN macro increments a call-depth counter.  So long 
-as this counter is small, the body of the deallocator is run directly without 
-further ado.  But if the counter gets large, it instead adds p to a list of 
-objects to be deallocated later, skips the body of the deallocator, and 
-resumes execution after the END macro.  The tp_dealloc routine then returns 
-without deallocating anything (and so unbounded call-stack depth is avoided). 
- 
-When the call stack finishes unwinding again, code generated by the END macro 
-notices this, and calls another routine to deallocate all the objects that 
-may have been added to the list of deferred deallocations.  In effect, a 
-chain of N deallocations is broken into (N-1)/(PyTrash_UNWIND_LEVEL-1) pieces, 
-with the call stack never exceeding a depth of PyTrash_UNWIND_LEVEL. 
- 
-Since the tp_dealloc of a subclass typically calls the tp_dealloc of the base 
-class, we need to ensure that the trashcan is only triggered on the tp_dealloc 
-of the actual class being deallocated. Otherwise we might end up with a 
-partially-deallocated object. To check this, the tp_dealloc function must be 
-passed as second argument to Py_TRASHCAN_BEGIN(). 
-*/ 
- 
-/* This is the old private API, invoked by the macros before 3.2.4. 
-   Kept for binary compatibility of extensions using the stable ABI. */ 
-PyAPI_FUNC(void) _PyTrash_deposit_object(PyObject*); 
-PyAPI_FUNC(void) _PyTrash_destroy_chain(void); 
- 
-/* This is the old private API, invoked by the macros before 3.9. 
-   Kept for binary compatibility of extensions using the stable ABI. */ 
-PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyObject*); 
-PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(void); 
- 
-/* Forward declarations for PyThreadState */ 
-struct _ts; 
- 
-/* Python 3.9 private API, invoked by the macros below. */ 
-PyAPI_FUNC(int) _PyTrash_begin(struct _ts *tstate, PyObject *op); 
-PyAPI_FUNC(void) _PyTrash_end(struct _ts *tstate); 
- 
-#define PyTrash_UNWIND_LEVEL 50 
- 
-#define Py_TRASHCAN_BEGIN_CONDITION(op, cond) \ 
-    do { \ 
-        PyThreadState *_tstate = NULL; \ 
-        /* If "cond" is false, then _tstate remains NULL and the deallocator \ 
-         * is run normally without involving the trashcan */ \ 
-        if (cond) { \ 
-            _tstate = PyThreadState_GET(); \ 
-            if (_PyTrash_begin(_tstate, _PyObject_CAST(op))) { \ 
-                break; \ 
-            } \ 
-        } 
-        /* The body of the deallocator is here. */ 
-#define Py_TRASHCAN_END \ 
-        if (_tstate) { \ 
-            _PyTrash_end(_tstate); \ 
-        } \ 
-    } while (0); 
- 
-#define Py_TRASHCAN_BEGIN(op, dealloc) \ 
-    Py_TRASHCAN_BEGIN_CONDITION(op, \ 
-        Py_TYPE(op)->tp_dealloc == (destructor)(dealloc)) 
- 
-/* For backwards compatibility, these macros enable the trashcan 
- * unconditionally */ 
-#define Py_TRASHCAN_SAFE_BEGIN(op) Py_TRASHCAN_BEGIN_CONDITION(op, 1) 
-#define Py_TRASHCAN_SAFE_END(op) Py_TRASHCAN_END 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_OBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(void) _Py_NewReference(PyObject *op);
+
+#ifdef Py_TRACE_REFS
+/* Py_TRACE_REFS is such major surgery that we call external routines. */
+PyAPI_FUNC(void) _Py_ForgetReference(PyObject *);
+#endif
+
+/* Update the Python traceback of an object. This function must be called
+   when a memory block is reused from a free list. */
+PyAPI_FUNC(int) _PyTraceMalloc_NewReference(PyObject *op);
+
+#ifdef Py_REF_DEBUG
+PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void);
+#endif
+
+
+/********************* String Literals ****************************************/
+/* This structure helps managing static strings. The basic usage goes like this:
+   Instead of doing
+
+       r = PyObject_CallMethod(o, "foo", "args", ...);
+
+   do
+
+       _Py_IDENTIFIER(foo);
+       ...
+       r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...);
+
+   PyId_foo is a static variable, either on block level or file level. On first
+   usage, the string "foo" is interned, and the structures are linked. On interpreter
+   shutdown, all strings are released.
+
+   Alternatively, _Py_static_string allows choosing the variable name.
+   _PyUnicode_FromId returns a borrowed reference to the interned string.
+   _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*.
+*/
+typedef struct _Py_Identifier {
+    struct _Py_Identifier *next;
+    const char* string;
+    PyObject *object;
+} _Py_Identifier;
+
+#define _Py_static_string_init(value) { .next = NULL, .string = value, .object = NULL }
+#define _Py_static_string(varname, value)  static _Py_Identifier varname = _Py_static_string_init(value)
+#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname)
+
+/* buffer interface */
+typedef struct bufferinfo {
+    void *buf;
+    PyObject *obj;        /* owned reference */
+    Py_ssize_t len;
+    Py_ssize_t itemsize;  /* This is Py_ssize_t so it can be
+                             pointed to by strides in simple case.*/
+    int readonly;
+    int ndim;
+    char *format;
+    Py_ssize_t *shape;
+    Py_ssize_t *strides;
+    Py_ssize_t *suboffsets;
+    void *internal;
+} Py_buffer;
+
+typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
+typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
+
+typedef PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                    size_t nargsf, PyObject *kwnames);
+
+/* Maximum number of dimensions */
+#define PyBUF_MAX_NDIM 64
+
+/* Flags for getting buffers */
+#define PyBUF_SIMPLE 0
+#define PyBUF_WRITABLE 0x0001
+/*  we used to include an E, backwards compatible alias  */
+#define PyBUF_WRITEABLE PyBUF_WRITABLE
+#define PyBUF_FORMAT 0x0004
+#define PyBUF_ND 0x0008
+#define PyBUF_STRIDES (0x0010 | PyBUF_ND)
+#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)
+#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)
+#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)
+#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)
+
+#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE)
+#define PyBUF_CONTIG_RO (PyBUF_ND)
+
+#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE)
+#define PyBUF_STRIDED_RO (PyBUF_STRIDES)
+
+#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT)
+#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT)
+
+#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT)
+#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT)
+
+
+#define PyBUF_READ  0x100
+#define PyBUF_WRITE 0x200
+/* End buffer interface */
+
+
+typedef struct {
+    /* Number implementations must check *both*
+       arguments for proper type and implement the necessary conversions
+       in the slot functions themselves. */
+
+    binaryfunc nb_add;
+    binaryfunc nb_subtract;
+    binaryfunc nb_multiply;
+    binaryfunc nb_remainder;
+    binaryfunc nb_divmod;
+    ternaryfunc nb_power;
+    unaryfunc nb_negative;
+    unaryfunc nb_positive;
+    unaryfunc nb_absolute;
+    inquiry nb_bool;
+    unaryfunc nb_invert;
+    binaryfunc nb_lshift;
+    binaryfunc nb_rshift;
+    binaryfunc nb_and;
+    binaryfunc nb_xor;
+    binaryfunc nb_or;
+    unaryfunc nb_int;
+    void *nb_reserved;  /* the slot formerly known as nb_long */
+    unaryfunc nb_float;
+
+    binaryfunc nb_inplace_add;
+    binaryfunc nb_inplace_subtract;
+    binaryfunc nb_inplace_multiply;
+    binaryfunc nb_inplace_remainder;
+    ternaryfunc nb_inplace_power;
+    binaryfunc nb_inplace_lshift;
+    binaryfunc nb_inplace_rshift;
+    binaryfunc nb_inplace_and;
+    binaryfunc nb_inplace_xor;
+    binaryfunc nb_inplace_or;
+
+    binaryfunc nb_floor_divide;
+    binaryfunc nb_true_divide;
+    binaryfunc nb_inplace_floor_divide;
+    binaryfunc nb_inplace_true_divide;
+
+    unaryfunc nb_index;
+
+    binaryfunc nb_matrix_multiply;
+    binaryfunc nb_inplace_matrix_multiply;
+} PyNumberMethods;
+
+typedef struct {
+    lenfunc sq_length;
+    binaryfunc sq_concat;
+    ssizeargfunc sq_repeat;
+    ssizeargfunc sq_item;
+    void *was_sq_slice;
+    ssizeobjargproc sq_ass_item;
+    void *was_sq_ass_slice;
+    objobjproc sq_contains;
+
+    binaryfunc sq_inplace_concat;
+    ssizeargfunc sq_inplace_repeat;
+} PySequenceMethods;
+
+typedef struct {
+    lenfunc mp_length;
+    binaryfunc mp_subscript;
+    objobjargproc mp_ass_subscript;
+} PyMappingMethods;
+
+typedef struct {
+    unaryfunc am_await;
+    unaryfunc am_aiter;
+    unaryfunc am_anext;
+} PyAsyncMethods;
+
+typedef struct {
+     getbufferproc bf_getbuffer;
+     releasebufferproc bf_releasebuffer;
+} PyBufferProcs;
+
+/* Allow printfunc in the tp_vectorcall_offset slot for
+ * backwards-compatibility */
+typedef Py_ssize_t printfunc;
+
+struct _typeobject {
+    PyObject_VAR_HEAD
+    const char *tp_name; /* For printing, in format "<module>.<name>" */
+    Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
+
+    /* Methods to implement standard operations */
+
+    destructor tp_dealloc;
+    Py_ssize_t tp_vectorcall_offset;
+    getattrfunc tp_getattr;
+    setattrfunc tp_setattr;
+    PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
+                                    or tp_reserved (Python 3) */
+    reprfunc tp_repr;
+
+    /* Method suites for standard classes */
+
+    PyNumberMethods *tp_as_number;
+    PySequenceMethods *tp_as_sequence;
+    PyMappingMethods *tp_as_mapping;
+
+    /* More standard operations (here for binary compatibility) */
+
+    hashfunc tp_hash;
+    ternaryfunc tp_call;
+    reprfunc tp_str;
+    getattrofunc tp_getattro;
+    setattrofunc tp_setattro;
+
+    /* Functions to access object as input/output buffer */
+    PyBufferProcs *tp_as_buffer;
+
+    /* Flags to define presence of optional/expanded features */
+    unsigned long tp_flags;
+
+    const char *tp_doc; /* Documentation string */
+
+    /* Assigned meaning in release 2.0 */
+    /* call function for all accessible objects */
+    traverseproc tp_traverse;
+
+    /* delete references to contained objects */
+    inquiry tp_clear;
+
+    /* Assigned meaning in release 2.1 */
+    /* rich comparisons */
+    richcmpfunc tp_richcompare;
+
+    /* weak reference enabler */
+    Py_ssize_t tp_weaklistoffset;
+
+    /* Iterators */
+    getiterfunc tp_iter;
+    iternextfunc tp_iternext;
+
+    /* Attribute descriptor and subclassing stuff */
+    struct PyMethodDef *tp_methods;
+    struct PyMemberDef *tp_members;
+    struct PyGetSetDef *tp_getset;
+    struct _typeobject *tp_base;
+    PyObject *tp_dict;
+    descrgetfunc tp_descr_get;
+    descrsetfunc tp_descr_set;
+    Py_ssize_t tp_dictoffset;
+    initproc tp_init;
+    allocfunc tp_alloc;
+    newfunc tp_new;
+    freefunc tp_free; /* Low-level free-memory routine */
+    inquiry tp_is_gc; /* For PyObject_IS_GC */
+    PyObject *tp_bases;
+    PyObject *tp_mro; /* method resolution order */
+    PyObject *tp_cache;
+    PyObject *tp_subclasses;
+    PyObject *tp_weaklist;
+    destructor tp_del;
+
+    /* Type attribute cache version tag. Added in version 2.6 */
+    unsigned int tp_version_tag;
+
+    destructor tp_finalize;
+    vectorcallfunc tp_vectorcall;
+};
+
+/* The *real* layout of a type object when allocated on the heap */
+typedef struct _heaptypeobject {
+    /* Note: there's a dependency on the order of these members
+       in slotptr() in typeobject.c . */
+    PyTypeObject ht_type;
+    PyAsyncMethods as_async;
+    PyNumberMethods as_number;
+    PyMappingMethods as_mapping;
+    PySequenceMethods as_sequence; /* as_sequence comes after as_mapping,
+                                      so that the mapping wins when both
+                                      the mapping and the sequence define
+                                      a given operator (e.g. __getitem__).
+                                      see add_operators() in typeobject.c . */
+    PyBufferProcs as_buffer;
+    PyObject *ht_name, *ht_slots, *ht_qualname;
+    struct _dictkeysobject *ht_cached_keys;
+    PyObject *ht_module;
+    /* here are optional user slots, followed by the members. */
+} PyHeapTypeObject;
+
+/* access macro to the members which are floating "behind" the object */
+#define PyHeapType_GET_MEMBERS(etype) \
+    ((PyMemberDef *)(((char *)etype) + Py_TYPE(etype)->tp_basicsize))
+
+PyAPI_FUNC(const char *) _PyType_Name(PyTypeObject *);
+PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *);
+PyAPI_FUNC(PyObject *) _PyType_LookupId(PyTypeObject *, _Py_Identifier *);
+PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, _Py_Identifier *);
+PyAPI_FUNC(PyTypeObject *) _PyType_CalculateMetaclass(PyTypeObject *, PyObject *);
+PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *);
+PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *);
+
+struct _Py_Identifier;
+PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int);
+PyAPI_FUNC(void) _Py_BreakPoint(void);
+PyAPI_FUNC(void) _PyObject_Dump(PyObject *);
+PyAPI_FUNC(int) _PyObject_IsFreed(PyObject *);
+
+PyAPI_FUNC(int) _PyObject_IsAbstract(PyObject *);
+PyAPI_FUNC(PyObject *) _PyObject_GetAttrId(PyObject *, struct _Py_Identifier *);
+PyAPI_FUNC(int) _PyObject_SetAttrId(PyObject *, struct _Py_Identifier *, PyObject *);
+PyAPI_FUNC(int) _PyObject_HasAttrId(PyObject *, struct _Py_Identifier *);
+/* Replacements of PyObject_GetAttr() and _PyObject_GetAttrId() which
+   don't raise AttributeError.
+
+   Return 1 and set *result != NULL if an attribute is found.
+   Return 0 and set *result == NULL if an attribute is not found;
+   an AttributeError is silenced.
+   Return -1 and set *result == NULL if an error other than AttributeError
+   is raised.
+*/
+PyAPI_FUNC(int) _PyObject_LookupAttr(PyObject *, PyObject *, PyObject **);
+PyAPI_FUNC(int) _PyObject_LookupAttrId(PyObject *, struct _Py_Identifier *, PyObject **);
+
+PyAPI_FUNC(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *);
+PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *);
+PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *);
+PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *);
+
+/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes
+   dict as the last parameter. */
+PyAPI_FUNC(PyObject *)
+_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *, int);
+PyAPI_FUNC(int)
+_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *,
+                                 PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) _PyObject_FunctionStr(PyObject *);
+
+/* Safely decref `op` and set `op` to `op2`.
+ *
+ * As in case of Py_CLEAR "the obvious" code can be deadly:
+ *
+ *     Py_DECREF(op);
+ *     op = op2;
+ *
+ * The safe way is:
+ *
+ *      Py_SETREF(op, op2);
+ *
+ * That arranges to set `op` to `op2` _before_ decref'ing, so that any code
+ * triggered as a side-effect of `op` getting torn down no longer believes
+ * `op` points to a valid object.
+ *
+ * Py_XSETREF is a variant of Py_SETREF that uses Py_XDECREF instead of
+ * Py_DECREF.
+ */
+
+#define Py_SETREF(op, op2)                      \
+    do {                                        \
+        PyObject *_py_tmp = _PyObject_CAST(op); \
+        (op) = (op2);                           \
+        Py_DECREF(_py_tmp);                     \
+    } while (0)
+
+#define Py_XSETREF(op, op2)                     \
+    do {                                        \
+        PyObject *_py_tmp = _PyObject_CAST(op); \
+        (op) = (op2);                           \
+        Py_XDECREF(_py_tmp);                    \
+    } while (0)
+
+
+PyAPI_DATA(PyTypeObject) _PyNone_Type;
+PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type;
+
+/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE.
+ * Defined in object.c.
+ */
+PyAPI_DATA(int) _Py_SwappedOp[];
+
+PyAPI_FUNC(void)
+_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks,
+                       size_t sizeof_block);
+PyAPI_FUNC(void)
+_PyObject_DebugTypeStats(FILE *out);
+
+/* Define a pair of assertion macros:
+   _PyObject_ASSERT_FROM(), _PyObject_ASSERT_WITH_MSG() and _PyObject_ASSERT().
+
+   These work like the regular C assert(), in that they will abort the
+   process with a message on stderr if the given condition fails to hold,
+   but compile away to nothing if NDEBUG is defined.
+
+   However, before aborting, Python will also try to call _PyObject_Dump() on
+   the given object.  This may be of use when investigating bugs in which a
+   particular object is corrupt (e.g. buggy a tp_visit method in an extension
+   module breaking the garbage collector), to help locate the broken objects.
+
+   The WITH_MSG variant allows you to supply an additional message that Python
+   will attempt to print to stderr, after the object dump. */
+#ifdef NDEBUG
+   /* No debugging: compile away the assertions: */
+#  define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \
+    ((void)0)
+#else
+   /* With debugging: generate checks: */
+#  define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \
+    ((expr) \
+      ? (void)(0) \
+      : _PyObject_AssertFailed((obj), Py_STRINGIFY(expr), \
+                               (msg), (filename), (lineno), (func)))
+#endif
+
+#define _PyObject_ASSERT_WITH_MSG(obj, expr, msg) \
+    _PyObject_ASSERT_FROM(obj, expr, msg, __FILE__, __LINE__, __func__)
+#define _PyObject_ASSERT(obj, expr) \
+    _PyObject_ASSERT_WITH_MSG(obj, expr, NULL)
+
+#define _PyObject_ASSERT_FAILED_MSG(obj, msg) \
+    _PyObject_AssertFailed((obj), NULL, (msg), __FILE__, __LINE__, __func__)
+
+/* Declare and define _PyObject_AssertFailed() even when NDEBUG is defined,
+   to avoid causing compiler/linker errors when building extensions without
+   NDEBUG against a Python built with NDEBUG defined.
+
+   msg, expr and function can be NULL. */
+PyAPI_FUNC(void) _Py_NO_RETURN _PyObject_AssertFailed(
+    PyObject *obj,
+    const char *expr,
+    const char *msg,
+    const char *file,
+    int line,
+    const char *function);
+
+/* Check if an object is consistent. For example, ensure that the reference
+   counter is greater than or equal to 1, and ensure that ob_type is not NULL.
+
+   Call _PyObject_AssertFailed() if the object is inconsistent.
+
+   If check_content is zero, only check header fields: reduce the overhead.
+
+   The function always return 1. The return value is just here to be able to
+   write:
+
+   assert(_PyObject_CheckConsistency(obj, 1)); */
+PyAPI_FUNC(int) _PyObject_CheckConsistency(
+    PyObject *op,
+    int check_content);
+
+
+/* Trashcan mechanism, thanks to Christian Tismer.
+
+When deallocating a container object, it's possible to trigger an unbounded
+chain of deallocations, as each Py_DECREF in turn drops the refcount on "the
+next" object in the chain to 0.  This can easily lead to stack overflows,
+especially in threads (which typically have less stack space to work with).
+
+A container object can avoid this by bracketing the body of its tp_dealloc
+function with a pair of macros:
+
+static void
+mytype_dealloc(mytype *p)
+{
+    ... declarations go here ...
+
+    PyObject_GC_UnTrack(p);        // must untrack first
+    Py_TRASHCAN_BEGIN(p, mytype_dealloc)
+    ... The body of the deallocator goes here, including all calls ...
+    ... to Py_DECREF on contained objects.                         ...
+    Py_TRASHCAN_END                // there should be no code after this
+}
+
+CAUTION:  Never return from the middle of the body!  If the body needs to
+"get out early", put a label immediately before the Py_TRASHCAN_END
+call, and goto it.  Else the call-depth counter (see below) will stay
+above 0 forever, and the trashcan will never get emptied.
+
+How it works:  The BEGIN macro increments a call-depth counter.  So long
+as this counter is small, the body of the deallocator is run directly without
+further ado.  But if the counter gets large, it instead adds p to a list of
+objects to be deallocated later, skips the body of the deallocator, and
+resumes execution after the END macro.  The tp_dealloc routine then returns
+without deallocating anything (and so unbounded call-stack depth is avoided).
+
+When the call stack finishes unwinding again, code generated by the END macro
+notices this, and calls another routine to deallocate all the objects that
+may have been added to the list of deferred deallocations.  In effect, a
+chain of N deallocations is broken into (N-1)/(PyTrash_UNWIND_LEVEL-1) pieces,
+with the call stack never exceeding a depth of PyTrash_UNWIND_LEVEL.
+
+Since the tp_dealloc of a subclass typically calls the tp_dealloc of the base
+class, we need to ensure that the trashcan is only triggered on the tp_dealloc
+of the actual class being deallocated. Otherwise we might end up with a
+partially-deallocated object. To check this, the tp_dealloc function must be
+passed as second argument to Py_TRASHCAN_BEGIN().
+*/
+
+/* This is the old private API, invoked by the macros before 3.2.4.
+   Kept for binary compatibility of extensions using the stable ABI. */
+PyAPI_FUNC(void) _PyTrash_deposit_object(PyObject*);
+PyAPI_FUNC(void) _PyTrash_destroy_chain(void);
+
+/* This is the old private API, invoked by the macros before 3.9.
+   Kept for binary compatibility of extensions using the stable ABI. */
+PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyObject*);
+PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(void);
+
+/* Forward declarations for PyThreadState */
+struct _ts;
+
+/* Python 3.9 private API, invoked by the macros below. */
+PyAPI_FUNC(int) _PyTrash_begin(struct _ts *tstate, PyObject *op);
+PyAPI_FUNC(void) _PyTrash_end(struct _ts *tstate);
+
+#define PyTrash_UNWIND_LEVEL 50
+
+#define Py_TRASHCAN_BEGIN_CONDITION(op, cond) \
+    do { \
+        PyThreadState *_tstate = NULL; \
+        /* If "cond" is false, then _tstate remains NULL and the deallocator \
+         * is run normally without involving the trashcan */ \
+        if (cond) { \
+            _tstate = PyThreadState_GET(); \
+            if (_PyTrash_begin(_tstate, _PyObject_CAST(op))) { \
+                break; \
+            } \
+        }
+        /* The body of the deallocator is here. */
+#define Py_TRASHCAN_END \
+        if (_tstate) { \
+            _PyTrash_end(_tstate); \
+        } \
+    } while (0);
+
+#define Py_TRASHCAN_BEGIN(op, dealloc) \
+    Py_TRASHCAN_BEGIN_CONDITION(op, \
+        Py_TYPE(op)->tp_dealloc == (destructor)(dealloc))
+
+/* For backwards compatibility, these macros enable the trashcan
+ * unconditionally */
+#define Py_TRASHCAN_SAFE_BEGIN(op) Py_TRASHCAN_BEGIN_CONDITION(op, 1)
+#define Py_TRASHCAN_SAFE_END(op) Py_TRASHCAN_END
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/objimpl.h b/contrib/tools/python3/src/Include/cpython/objimpl.h
index b69dca71a2..b835936db7 100644
--- a/contrib/tools/python3/src/Include/cpython/objimpl.h
+++ b/contrib/tools/python3/src/Include/cpython/objimpl.h
@@ -1,145 +1,145 @@
-#ifndef Py_CPYTHON_OBJIMPL_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-#define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize ) 
- 
-/* _PyObject_VAR_SIZE returns the number of bytes (as size_t) allocated for a 
-   vrbl-size object with nitems items, exclusive of gc overhead (if any).  The 
-   value is rounded up to the closest multiple of sizeof(void *), in order to 
-   ensure that pointer fields at the end of the object are correctly aligned 
-   for the platform (this is of special importance for subclasses of, e.g., 
-   str or int, so that pointers can be stored after the embedded data). 
- 
-   Note that there's no memory wastage in doing this, as malloc has to 
-   return (at worst) pointer-aligned memory anyway. 
-*/ 
-#if ((SIZEOF_VOID_P - 1) & SIZEOF_VOID_P) != 0 
-#   error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2" 
-#endif 
- 
-#define _PyObject_VAR_SIZE(typeobj, nitems)     \ 
-    _Py_SIZE_ROUND_UP((typeobj)->tp_basicsize + \ 
-        (nitems)*(typeobj)->tp_itemsize,        \ 
-        SIZEOF_VOID_P) 
- 
- 
-/* This example code implements an object constructor with a custom 
-   allocator, where PyObject_New is inlined, and shows the important 
-   distinction between two steps (at least): 
-       1) the actual allocation of the object storage; 
-       2) the initialization of the Python specific fields 
-      in this storage with PyObject_{Init, InitVar}. 
- 
-   PyObject * 
-   YourObject_New(...) 
-   { 
-       PyObject *op; 
- 
-       op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct)); 
-       if (op == NULL) 
-       return PyErr_NoMemory(); 
- 
-       PyObject_Init(op, &YourTypeStruct); 
- 
-       op->ob_field = value; 
-       ... 
-       return op; 
-   } 
- 
-   Note that in C++, the use of the new operator usually implies that 
-   the 1st step is performed automatically for you, so in a C++ class 
-   constructor you would start directly with PyObject_Init/InitVar. */ 
- 
- 
-/* Inline functions trading binary compatibility for speed: 
-   PyObject_INIT() is the fast version of PyObject_Init(), and 
-   PyObject_INIT_VAR() is the fast version of PyObject_InitVar(). 
- 
-   These inline functions must not be called with op=NULL. */ 
-static inline PyObject* 
-_PyObject_INIT(PyObject *op, PyTypeObject *typeobj) 
-{ 
-    assert(op != NULL); 
-    Py_SET_TYPE(op, typeobj); 
-    if (PyType_GetFlags(typeobj) & Py_TPFLAGS_HEAPTYPE) { 
-        Py_INCREF(typeobj); 
-    } 
-    _Py_NewReference(op); 
-    return op; 
-} 
- 
-#define PyObject_INIT(op, typeobj) \ 
-    _PyObject_INIT(_PyObject_CAST(op), (typeobj)) 
- 
-static inline PyVarObject* 
-_PyObject_INIT_VAR(PyVarObject *op, PyTypeObject *typeobj, Py_ssize_t size) 
-{ 
-    assert(op != NULL); 
-    Py_SET_SIZE(op, size); 
-    PyObject_INIT((PyObject *)op, typeobj); 
-    return op; 
-} 
- 
-#define PyObject_INIT_VAR(op, typeobj, size) \ 
-    _PyObject_INIT_VAR(_PyVarObject_CAST(op), (typeobj), (size)) 
- 
- 
-/* This function returns the number of allocated memory blocks, regardless of size */ 
-PyAPI_FUNC(Py_ssize_t) _Py_GetAllocatedBlocks(void); 
- 
-/* Macros */ 
-#ifdef WITH_PYMALLOC 
-PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE *out); 
-#endif 
- 
- 
-typedef struct { 
-    /* user context passed as the first argument to the 2 functions */ 
-    void *ctx; 
- 
-    /* allocate an arena of size bytes */ 
-    void* (*alloc) (void *ctx, size_t size); 
- 
-    /* free an arena */ 
-    void (*free) (void *ctx, void *ptr, size_t size); 
-} PyObjectArenaAllocator; 
- 
-/* Get the arena allocator. */ 
-PyAPI_FUNC(void) PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator); 
- 
-/* Set the arena allocator. */ 
-PyAPI_FUNC(void) PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator); 
- 
- 
-PyAPI_FUNC(Py_ssize_t) _PyGC_CollectNoFail(void); 
-PyAPI_FUNC(Py_ssize_t) _PyGC_CollectIfEnabled(void); 
- 
- 
-/* Test if an object implements the garbage collector protocol */ 
-PyAPI_FUNC(int) PyObject_IS_GC(PyObject *obj); 
- 
- 
-/* Code built with Py_BUILD_CORE must include pycore_gc.h instead which 
-   defines a different _PyGC_FINALIZED() macro. */ 
-#ifndef Py_BUILD_CORE 
-   // Kept for backward compatibility with Python 3.8 
-#  define _PyGC_FINALIZED(o) PyObject_GC_IsFinalized(o) 
-#endif 
- 
-PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t size); 
-PyAPI_FUNC(PyObject *) _PyObject_GC_Calloc(size_t size); 
- 
- 
-/* Test if a type supports weak references */ 
-#define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0) 
- 
-PyAPI_FUNC(PyObject **) PyObject_GET_WEAKREFS_LISTPTR(PyObject *op); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_OBJIMPL_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize )
+
+/* _PyObject_VAR_SIZE returns the number of bytes (as size_t) allocated for a
+   vrbl-size object with nitems items, exclusive of gc overhead (if any).  The
+   value is rounded up to the closest multiple of sizeof(void *), in order to
+   ensure that pointer fields at the end of the object are correctly aligned
+   for the platform (this is of special importance for subclasses of, e.g.,
+   str or int, so that pointers can be stored after the embedded data).
+
+   Note that there's no memory wastage in doing this, as malloc has to
+   return (at worst) pointer-aligned memory anyway.
+*/
+#if ((SIZEOF_VOID_P - 1) & SIZEOF_VOID_P) != 0
+#   error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2"
+#endif
+
+#define _PyObject_VAR_SIZE(typeobj, nitems)     \
+    _Py_SIZE_ROUND_UP((typeobj)->tp_basicsize + \
+        (nitems)*(typeobj)->tp_itemsize,        \
+        SIZEOF_VOID_P)
+
+
+/* This example code implements an object constructor with a custom
+   allocator, where PyObject_New is inlined, and shows the important
+   distinction between two steps (at least):
+       1) the actual allocation of the object storage;
+       2) the initialization of the Python specific fields
+      in this storage with PyObject_{Init, InitVar}.
+
+   PyObject *
+   YourObject_New(...)
+   {
+       PyObject *op;
+
+       op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct));
+       if (op == NULL)
+       return PyErr_NoMemory();
+
+       PyObject_Init(op, &YourTypeStruct);
+
+       op->ob_field = value;
+       ...
+       return op;
+   }
+
+   Note that in C++, the use of the new operator usually implies that
+   the 1st step is performed automatically for you, so in a C++ class
+   constructor you would start directly with PyObject_Init/InitVar. */
+
+
+/* Inline functions trading binary compatibility for speed:
+   PyObject_INIT() is the fast version of PyObject_Init(), and
+   PyObject_INIT_VAR() is the fast version of PyObject_InitVar().
+
+   These inline functions must not be called with op=NULL. */
+static inline PyObject*
+_PyObject_INIT(PyObject *op, PyTypeObject *typeobj)
+{
+    assert(op != NULL);
+    Py_SET_TYPE(op, typeobj);
+    if (PyType_GetFlags(typeobj) & Py_TPFLAGS_HEAPTYPE) {
+        Py_INCREF(typeobj);
+    }
+    _Py_NewReference(op);
+    return op;
+}
+
+#define PyObject_INIT(op, typeobj) \
+    _PyObject_INIT(_PyObject_CAST(op), (typeobj))
+
+static inline PyVarObject*
+_PyObject_INIT_VAR(PyVarObject *op, PyTypeObject *typeobj, Py_ssize_t size)
+{
+    assert(op != NULL);
+    Py_SET_SIZE(op, size);
+    PyObject_INIT((PyObject *)op, typeobj);
+    return op;
+}
+
+#define PyObject_INIT_VAR(op, typeobj, size) \
+    _PyObject_INIT_VAR(_PyVarObject_CAST(op), (typeobj), (size))
+
+
+/* This function returns the number of allocated memory blocks, regardless of size */
+PyAPI_FUNC(Py_ssize_t) _Py_GetAllocatedBlocks(void);
+
+/* Macros */
+#ifdef WITH_PYMALLOC
+PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE *out);
+#endif
+
+
+typedef struct {
+    /* user context passed as the first argument to the 2 functions */
+    void *ctx;
+
+    /* allocate an arena of size bytes */
+    void* (*alloc) (void *ctx, size_t size);
+
+    /* free an arena */
+    void (*free) (void *ctx, void *ptr, size_t size);
+} PyObjectArenaAllocator;
+
+/* Get the arena allocator. */
+PyAPI_FUNC(void) PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator);
+
+/* Set the arena allocator. */
+PyAPI_FUNC(void) PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator);
+
+
+PyAPI_FUNC(Py_ssize_t) _PyGC_CollectNoFail(void);
+PyAPI_FUNC(Py_ssize_t) _PyGC_CollectIfEnabled(void);
+
+
+/* Test if an object implements the garbage collector protocol */
+PyAPI_FUNC(int) PyObject_IS_GC(PyObject *obj);
+
+
+/* Code built with Py_BUILD_CORE must include pycore_gc.h instead which
+   defines a different _PyGC_FINALIZED() macro. */
+#ifndef Py_BUILD_CORE
+   // Kept for backward compatibility with Python 3.8
+#  define _PyGC_FINALIZED(o) PyObject_GC_IsFinalized(o)
+#endif
+
+PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t size);
+PyAPI_FUNC(PyObject *) _PyObject_GC_Calloc(size_t size);
+
+
+/* Test if a type supports weak references */
+#define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0)
+
+PyAPI_FUNC(PyObject **) PyObject_GET_WEAKREFS_LISTPTR(PyObject *op);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/pyerrors.h b/contrib/tools/python3/src/Include/cpython/pyerrors.h
index 9d55575a4f..9c87b53979 100644
--- a/contrib/tools/python3/src/Include/cpython/pyerrors.h
+++ b/contrib/tools/python3/src/Include/cpython/pyerrors.h
@@ -1,200 +1,200 @@
-#ifndef Py_CPYTHON_ERRORS_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-/* Error objects */ 
- 
-/* PyException_HEAD defines the initial segment of every exception class. */ 
-#define PyException_HEAD PyObject_HEAD PyObject *dict;\ 
-             PyObject *args; PyObject *traceback;\ 
-             PyObject *context; PyObject *cause;\ 
-             char suppress_context; 
- 
-typedef struct { 
-    PyException_HEAD 
-} PyBaseExceptionObject; 
- 
-typedef struct { 
-    PyException_HEAD 
-    PyObject *msg; 
-    PyObject *filename; 
-    PyObject *lineno; 
-    PyObject *offset; 
-    PyObject *text; 
-    PyObject *print_file_and_line; 
-} PySyntaxErrorObject; 
- 
-typedef struct { 
-    PyException_HEAD 
-    PyObject *msg; 
-    PyObject *name; 
-    PyObject *path; 
-} PyImportErrorObject; 
- 
-typedef struct { 
-    PyException_HEAD 
-    PyObject *encoding; 
-    PyObject *object; 
-    Py_ssize_t start; 
-    Py_ssize_t end; 
-    PyObject *reason; 
-} PyUnicodeErrorObject; 
- 
-typedef struct { 
-    PyException_HEAD 
-    PyObject *code; 
-} PySystemExitObject; 
- 
-typedef struct { 
-    PyException_HEAD 
-    PyObject *myerrno; 
-    PyObject *strerror; 
-    PyObject *filename; 
-    PyObject *filename2; 
-#ifdef MS_WINDOWS 
-    PyObject *winerror; 
-#endif 
-    Py_ssize_t written;   /* only for BlockingIOError, -1 otherwise */ 
-} PyOSErrorObject; 
- 
-typedef struct { 
-    PyException_HEAD 
-    PyObject *value; 
-} PyStopIterationObject; 
- 
-/* Compatibility typedefs */ 
-typedef PyOSErrorObject PyEnvironmentErrorObject; 
-#ifdef MS_WINDOWS 
-typedef PyOSErrorObject PyWindowsErrorObject; 
-#endif 
- 
-/* Error handling definitions */ 
- 
-PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *); 
-PyAPI_FUNC(_PyErr_StackItem*) _PyErr_GetTopmostException(PyThreadState *tstate); 
-PyAPI_FUNC(void) _PyErr_GetExcInfo(PyThreadState *, PyObject **, PyObject **, PyObject **); 
- 
-/* Context manipulation (PEP 3134) */ 
- 
-PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *); 
- 
-/* */ 
- 
-#define PyExceptionClass_Name(x)  (((PyTypeObject*)(x))->tp_name) 
- 
-/* Convenience functions */ 
- 
-#ifdef MS_WINDOWS 
-Py_DEPRECATED(3.3) 
-PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename( 
-    PyObject *, const Py_UNICODE *); 
-#endif /* MS_WINDOWS */ 
- 
-/* Like PyErr_Format(), but saves current exception as __context__ and 
-   __cause__. 
- */ 
-PyAPI_FUNC(PyObject *) _PyErr_FormatFromCause( 
-    PyObject *exception, 
-    const char *format,   /* ASCII-encoded string  */ 
-    ... 
-    ); 
- 
-#ifdef MS_WINDOWS 
-/* XXX redeclare to use WSTRING */ 
-Py_DEPRECATED(3.3) 
-PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename( 
-    int, const Py_UNICODE *); 
-Py_DEPRECATED(3.3) 
-PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename( 
-    PyObject *,int, const Py_UNICODE *); 
-#endif 
- 
-/* In exceptions.c */ 
- 
-/* Helper that attempts to replace the current exception with one of the 
- * same type but with a prefix added to the exception text. The resulting 
- * exception description looks like: 
- * 
- *     prefix (exc_type: original_exc_str) 
- * 
- * Only some exceptions can be safely replaced. If the function determines 
- * it isn't safe to perform the replacement, it will leave the original 
- * unmodified exception in place. 
- * 
- * Returns a borrowed reference to the new exception (if any), NULL if the 
- * existing exception was left in place. 
- */ 
-PyAPI_FUNC(PyObject *) _PyErr_TrySetFromCause( 
-    const char *prefix_format,   /* ASCII-encoded string  */ 
-    ... 
-    ); 
- 
-/* In signalmodule.c */ 
- 
-int PySignal_SetWakeupFd(int fd); 
-PyAPI_FUNC(int) _PyErr_CheckSignals(void); 
- 
-/* Support for adding program text to SyntaxErrors */ 
- 
-PyAPI_FUNC(void) PyErr_SyntaxLocationObject( 
-    PyObject *filename, 
-    int lineno, 
-    int col_offset); 
- 
-PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject( 
-    PyObject *filename, 
-    int lineno); 
- 
-/* Create a UnicodeEncodeError object. 
- * 
- * TODO: This API will be removed in Python 3.11. 
- */ 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create( 
-    const char *encoding,       /* UTF-8 encoded string */ 
-    const Py_UNICODE *object, 
-    Py_ssize_t length, 
-    Py_ssize_t start, 
-    Py_ssize_t end, 
-    const char *reason          /* UTF-8 encoded string */ 
-    ); 
- 
-/* Create a UnicodeTranslateError object. 
- * 
- * TODO: This API will be removed in Python 3.11. 
- */ 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create( 
-    const Py_UNICODE *object, 
-    Py_ssize_t length, 
-    Py_ssize_t start, 
-    Py_ssize_t end, 
-    const char *reason          /* UTF-8 encoded string */ 
-    ); 
-PyAPI_FUNC(PyObject *) _PyUnicodeTranslateError_Create( 
-    PyObject *object, 
-    Py_ssize_t start, 
-    Py_ssize_t end, 
-    const char *reason          /* UTF-8 encoded string */ 
-    ); 
- 
-PyAPI_FUNC(void) _PyErr_WriteUnraisableMsg( 
-    const char *err_msg, 
-    PyObject *obj); 
- 
-PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFunc( 
-    const char *func, 
-    const char *message); 
- 
-PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFormat( 
-    const char *func, 
-    const char *format, 
-    ...); 
- 
-#define Py_FatalError(message) _Py_FatalErrorFunc(__func__, message) 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_ERRORS_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Error objects */
+
+/* PyException_HEAD defines the initial segment of every exception class. */
+#define PyException_HEAD PyObject_HEAD PyObject *dict;\
+             PyObject *args; PyObject *traceback;\
+             PyObject *context; PyObject *cause;\
+             char suppress_context;
+
+typedef struct {
+    PyException_HEAD
+} PyBaseExceptionObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *msg;
+    PyObject *filename;
+    PyObject *lineno;
+    PyObject *offset;
+    PyObject *text;
+    PyObject *print_file_and_line;
+} PySyntaxErrorObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *msg;
+    PyObject *name;
+    PyObject *path;
+} PyImportErrorObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *encoding;
+    PyObject *object;
+    Py_ssize_t start;
+    Py_ssize_t end;
+    PyObject *reason;
+} PyUnicodeErrorObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *code;
+} PySystemExitObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *myerrno;
+    PyObject *strerror;
+    PyObject *filename;
+    PyObject *filename2;
+#ifdef MS_WINDOWS
+    PyObject *winerror;
+#endif
+    Py_ssize_t written;   /* only for BlockingIOError, -1 otherwise */
+} PyOSErrorObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *value;
+} PyStopIterationObject;
+
+/* Compatibility typedefs */
+typedef PyOSErrorObject PyEnvironmentErrorObject;
+#ifdef MS_WINDOWS
+typedef PyOSErrorObject PyWindowsErrorObject;
+#endif
+
+/* Error handling definitions */
+
+PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *);
+PyAPI_FUNC(_PyErr_StackItem*) _PyErr_GetTopmostException(PyThreadState *tstate);
+PyAPI_FUNC(void) _PyErr_GetExcInfo(PyThreadState *, PyObject **, PyObject **, PyObject **);
+
+/* Context manipulation (PEP 3134) */
+
+PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *);
+
+/* */
+
+#define PyExceptionClass_Name(x)  (((PyTypeObject*)(x))->tp_name)
+
+/* Convenience functions */
+
+#ifdef MS_WINDOWS
+Py_DEPRECATED(3.3)
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(
+    PyObject *, const Py_UNICODE *);
+#endif /* MS_WINDOWS */
+
+/* Like PyErr_Format(), but saves current exception as __context__ and
+   __cause__.
+ */
+PyAPI_FUNC(PyObject *) _PyErr_FormatFromCause(
+    PyObject *exception,
+    const char *format,   /* ASCII-encoded string  */
+    ...
+    );
+
+#ifdef MS_WINDOWS
+/* XXX redeclare to use WSTRING */
+Py_DEPRECATED(3.3)
+PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(
+    int, const Py_UNICODE *);
+Py_DEPRECATED(3.3)
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(
+    PyObject *,int, const Py_UNICODE *);
+#endif
+
+/* In exceptions.c */
+
+/* Helper that attempts to replace the current exception with one of the
+ * same type but with a prefix added to the exception text. The resulting
+ * exception description looks like:
+ *
+ *     prefix (exc_type: original_exc_str)
+ *
+ * Only some exceptions can be safely replaced. If the function determines
+ * it isn't safe to perform the replacement, it will leave the original
+ * unmodified exception in place.
+ *
+ * Returns a borrowed reference to the new exception (if any), NULL if the
+ * existing exception was left in place.
+ */
+PyAPI_FUNC(PyObject *) _PyErr_TrySetFromCause(
+    const char *prefix_format,   /* ASCII-encoded string  */
+    ...
+    );
+
+/* In signalmodule.c */
+
+int PySignal_SetWakeupFd(int fd);
+PyAPI_FUNC(int) _PyErr_CheckSignals(void);
+
+/* Support for adding program text to SyntaxErrors */
+
+PyAPI_FUNC(void) PyErr_SyntaxLocationObject(
+    PyObject *filename,
+    int lineno,
+    int col_offset);
+
+PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject(
+    PyObject *filename,
+    int lineno);
+
+/* Create a UnicodeEncodeError object.
+ *
+ * TODO: This API will be removed in Python 3.11.
+ */
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(
+    const char *encoding,       /* UTF-8 encoded string */
+    const Py_UNICODE *object,
+    Py_ssize_t length,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    const char *reason          /* UTF-8 encoded string */
+    );
+
+/* Create a UnicodeTranslateError object.
+ *
+ * TODO: This API will be removed in Python 3.11.
+ */
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(
+    const Py_UNICODE *object,
+    Py_ssize_t length,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    const char *reason          /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(PyObject *) _PyUnicodeTranslateError_Create(
+    PyObject *object,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    const char *reason          /* UTF-8 encoded string */
+    );
+
+PyAPI_FUNC(void) _PyErr_WriteUnraisableMsg(
+    const char *err_msg,
+    PyObject *obj);
+
+PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFunc(
+    const char *func,
+    const char *message);
+
+PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFormat(
+    const char *func,
+    const char *format,
+    ...);
+
+#define Py_FatalError(message) _Py_FatalErrorFunc(__func__, message)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/pylifecycle.h b/contrib/tools/python3/src/Include/cpython/pylifecycle.h
index ebb6f48b3c..eb523b82e1 100644
--- a/contrib/tools/python3/src/Include/cpython/pylifecycle.h
+++ b/contrib/tools/python3/src/Include/cpython/pylifecycle.h
@@ -1,72 +1,72 @@
-#ifndef Py_CPYTHON_PYLIFECYCLE_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-/* Only used by applications that embed the interpreter and need to 
- * override the standard encoding determination mechanism 
- */ 
-PyAPI_FUNC(int) Py_SetStandardStreamEncoding(const char *encoding, 
-                                             const char *errors); 
- 
-/* PEP 432 Multi-phase initialization API (Private while provisional!) */ 
- 
-PyAPI_FUNC(PyStatus) Py_PreInitialize( 
-    const PyPreConfig *src_config); 
-PyAPI_FUNC(PyStatus) Py_PreInitializeFromBytesArgs( 
-    const PyPreConfig *src_config, 
-    Py_ssize_t argc, 
-    char **argv); 
-PyAPI_FUNC(PyStatus) Py_PreInitializeFromArgs( 
-    const PyPreConfig *src_config, 
-    Py_ssize_t argc, 
-    wchar_t **argv); 
- 
-PyAPI_FUNC(int) _Py_IsCoreInitialized(void); 
- 
- 
-/* Initialization and finalization */ 
- 
-PyAPI_FUNC(PyStatus) Py_InitializeFromConfig( 
-    const PyConfig *config); 
-PyAPI_FUNC(PyStatus) _Py_InitializeMain(void); 
- 
-PyAPI_FUNC(int) Py_RunMain(void); 
- 
- 
-PyAPI_FUNC(void) _Py_NO_RETURN Py_ExitStatusException(PyStatus err); 
- 
-/* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level 
- * exit functions. 
- */ 
-PyAPI_FUNC(void) _Py_PyAtExit(void (*func)(PyObject *), PyObject *); 
- 
-/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. */ 
-PyAPI_FUNC(void) _Py_RestoreSignals(void); 
- 
-PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *); 
- 
-PyAPI_FUNC(void) _Py_SetProgramFullPath(const wchar_t *); 
- 
-PyAPI_FUNC(const char *) _Py_gitidentifier(void); 
-PyAPI_FUNC(const char *) _Py_gitversion(void); 
- 
-PyAPI_FUNC(int) _Py_IsFinalizing(void); 
- 
-/* Random */ 
-PyAPI_FUNC(int) _PyOS_URandom(void *buffer, Py_ssize_t size); 
-PyAPI_FUNC(int) _PyOS_URandomNonblock(void *buffer, Py_ssize_t size); 
- 
-/* Legacy locale support */ 
-PyAPI_FUNC(int) _Py_CoerceLegacyLocale(int warn); 
-PyAPI_FUNC(int) _Py_LegacyLocaleDetected(int warn); 
-PyAPI_FUNC(char *) _Py_SetLocaleFromEnv(int category); 
- 
-PyAPI_FUNC(PyThreadState *) _Py_NewInterpreter(int isolated_subinterpreter); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_PYLIFECYCLE_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Only used by applications that embed the interpreter and need to
+ * override the standard encoding determination mechanism
+ */
+PyAPI_FUNC(int) Py_SetStandardStreamEncoding(const char *encoding,
+                                             const char *errors);
+
+/* PEP 432 Multi-phase initialization API (Private while provisional!) */
+
+PyAPI_FUNC(PyStatus) Py_PreInitialize(
+    const PyPreConfig *src_config);
+PyAPI_FUNC(PyStatus) Py_PreInitializeFromBytesArgs(
+    const PyPreConfig *src_config,
+    Py_ssize_t argc,
+    char **argv);
+PyAPI_FUNC(PyStatus) Py_PreInitializeFromArgs(
+    const PyPreConfig *src_config,
+    Py_ssize_t argc,
+    wchar_t **argv);
+
+PyAPI_FUNC(int) _Py_IsCoreInitialized(void);
+
+
+/* Initialization and finalization */
+
+PyAPI_FUNC(PyStatus) Py_InitializeFromConfig(
+    const PyConfig *config);
+PyAPI_FUNC(PyStatus) _Py_InitializeMain(void);
+
+PyAPI_FUNC(int) Py_RunMain(void);
+
+
+PyAPI_FUNC(void) _Py_NO_RETURN Py_ExitStatusException(PyStatus err);
+
+/* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level
+ * exit functions.
+ */
+PyAPI_FUNC(void) _Py_PyAtExit(void (*func)(PyObject *), PyObject *);
+
+/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. */
+PyAPI_FUNC(void) _Py_RestoreSignals(void);
+
+PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *);
+
+PyAPI_FUNC(void) _Py_SetProgramFullPath(const wchar_t *);
+
+PyAPI_FUNC(const char *) _Py_gitidentifier(void);
+PyAPI_FUNC(const char *) _Py_gitversion(void);
+
+PyAPI_FUNC(int) _Py_IsFinalizing(void);
+
+/* Random */
+PyAPI_FUNC(int) _PyOS_URandom(void *buffer, Py_ssize_t size);
+PyAPI_FUNC(int) _PyOS_URandomNonblock(void *buffer, Py_ssize_t size);
+
+/* Legacy locale support */
+PyAPI_FUNC(int) _Py_CoerceLegacyLocale(int warn);
+PyAPI_FUNC(int) _Py_LegacyLocaleDetected(int warn);
+PyAPI_FUNC(char *) _Py_SetLocaleFromEnv(int category);
+
+PyAPI_FUNC(PyThreadState *) _Py_NewInterpreter(int isolated_subinterpreter);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/pymem.h b/contrib/tools/python3/src/Include/cpython/pymem.h
index fb225556a2..79f063b121 100644
--- a/contrib/tools/python3/src/Include/cpython/pymem.h
+++ b/contrib/tools/python3/src/Include/cpython/pymem.h
@@ -1,108 +1,108 @@
-#ifndef Py_CPYTHON_PYMEM_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-PyAPI_FUNC(void *) PyMem_RawMalloc(size_t size); 
-PyAPI_FUNC(void *) PyMem_RawCalloc(size_t nelem, size_t elsize); 
-PyAPI_FUNC(void *) PyMem_RawRealloc(void *ptr, size_t new_size); 
-PyAPI_FUNC(void) PyMem_RawFree(void *ptr); 
- 
-/* Try to get the allocators name set by _PyMem_SetupAllocators(). */ 
-PyAPI_FUNC(const char*) _PyMem_GetCurrentAllocatorName(void); 
- 
-PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); 
- 
-/* strdup() using PyMem_RawMalloc() */ 
-PyAPI_FUNC(char *) _PyMem_RawStrdup(const char *str); 
- 
-/* strdup() using PyMem_Malloc() */ 
-PyAPI_FUNC(char *) _PyMem_Strdup(const char *str); 
- 
-/* wcsdup() using PyMem_RawMalloc() */ 
-PyAPI_FUNC(wchar_t*) _PyMem_RawWcsdup(const wchar_t *str); 
- 
- 
-typedef enum { 
-    /* PyMem_RawMalloc(), PyMem_RawRealloc() and PyMem_RawFree() */ 
-    PYMEM_DOMAIN_RAW, 
- 
-    /* PyMem_Malloc(), PyMem_Realloc() and PyMem_Free() */ 
-    PYMEM_DOMAIN_MEM, 
- 
-    /* PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() */ 
-    PYMEM_DOMAIN_OBJ 
-} PyMemAllocatorDomain; 
- 
-typedef enum { 
-    PYMEM_ALLOCATOR_NOT_SET = 0, 
-    PYMEM_ALLOCATOR_DEFAULT = 1, 
-    PYMEM_ALLOCATOR_DEBUG = 2, 
-    PYMEM_ALLOCATOR_MALLOC = 3, 
-    PYMEM_ALLOCATOR_MALLOC_DEBUG = 4, 
-#ifdef WITH_PYMALLOC 
-    PYMEM_ALLOCATOR_PYMALLOC = 5, 
-    PYMEM_ALLOCATOR_PYMALLOC_DEBUG = 6, 
-#endif 
-} PyMemAllocatorName; 
- 
- 
-typedef struct { 
-    /* user context passed as the first argument to the 4 functions */ 
-    void *ctx; 
- 
-    /* allocate a memory block */ 
-    void* (*malloc) (void *ctx, size_t size); 
- 
-    /* allocate a memory block initialized by zeros */ 
-    void* (*calloc) (void *ctx, size_t nelem, size_t elsize); 
- 
-    /* allocate or resize a memory block */ 
-    void* (*realloc) (void *ctx, void *ptr, size_t new_size); 
- 
-    /* release a memory block */ 
-    void (*free) (void *ctx, void *ptr); 
-} PyMemAllocatorEx; 
- 
-/* Get the memory block allocator of the specified domain. */ 
-PyAPI_FUNC(void) PyMem_GetAllocator(PyMemAllocatorDomain domain, 
-                                    PyMemAllocatorEx *allocator); 
- 
-/* Set the memory block allocator of the specified domain. 
- 
-   The new allocator must return a distinct non-NULL pointer when requesting 
-   zero bytes. 
- 
-   For the PYMEM_DOMAIN_RAW domain, the allocator must be thread-safe: the GIL 
-   is not held when the allocator is called. 
- 
-   If the new allocator is not a hook (don't call the previous allocator), the 
-   PyMem_SetupDebugHooks() function must be called to reinstall the debug hooks 
-   on top on the new allocator. */ 
-PyAPI_FUNC(void) PyMem_SetAllocator(PyMemAllocatorDomain domain, 
-                                    PyMemAllocatorEx *allocator); 
- 
-/* Setup hooks to detect bugs in the following Python memory allocator 
-   functions: 
- 
-   - PyMem_RawMalloc(), PyMem_RawRealloc(), PyMem_RawFree() 
-   - PyMem_Malloc(), PyMem_Realloc(), PyMem_Free() 
-   - PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() 
- 
-   Newly allocated memory is filled with the byte 0xCB, freed memory is filled 
-   with the byte 0xDB. Additional checks: 
- 
-   - detect API violations, ex: PyObject_Free() called on a buffer allocated 
-     by PyMem_Malloc() 
-   - detect write before the start of the buffer (buffer underflow) 
-   - detect write after the end of the buffer (buffer overflow) 
- 
-   The function does nothing if Python is not compiled is debug mode. */ 
-PyAPI_FUNC(void) PyMem_SetupDebugHooks(void); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_PYMEM_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(void *) PyMem_RawMalloc(size_t size);
+PyAPI_FUNC(void *) PyMem_RawCalloc(size_t nelem, size_t elsize);
+PyAPI_FUNC(void *) PyMem_RawRealloc(void *ptr, size_t new_size);
+PyAPI_FUNC(void) PyMem_RawFree(void *ptr);
+
+/* Try to get the allocators name set by _PyMem_SetupAllocators(). */
+PyAPI_FUNC(const char*) _PyMem_GetCurrentAllocatorName(void);
+
+PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize);
+
+/* strdup() using PyMem_RawMalloc() */
+PyAPI_FUNC(char *) _PyMem_RawStrdup(const char *str);
+
+/* strdup() using PyMem_Malloc() */
+PyAPI_FUNC(char *) _PyMem_Strdup(const char *str);
+
+/* wcsdup() using PyMem_RawMalloc() */
+PyAPI_FUNC(wchar_t*) _PyMem_RawWcsdup(const wchar_t *str);
+
+
+typedef enum {
+    /* PyMem_RawMalloc(), PyMem_RawRealloc() and PyMem_RawFree() */
+    PYMEM_DOMAIN_RAW,
+
+    /* PyMem_Malloc(), PyMem_Realloc() and PyMem_Free() */
+    PYMEM_DOMAIN_MEM,
+
+    /* PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() */
+    PYMEM_DOMAIN_OBJ
+} PyMemAllocatorDomain;
+
+typedef enum {
+    PYMEM_ALLOCATOR_NOT_SET = 0,
+    PYMEM_ALLOCATOR_DEFAULT = 1,
+    PYMEM_ALLOCATOR_DEBUG = 2,
+    PYMEM_ALLOCATOR_MALLOC = 3,
+    PYMEM_ALLOCATOR_MALLOC_DEBUG = 4,
+#ifdef WITH_PYMALLOC
+    PYMEM_ALLOCATOR_PYMALLOC = 5,
+    PYMEM_ALLOCATOR_PYMALLOC_DEBUG = 6,
+#endif
+} PyMemAllocatorName;
+
+
+typedef struct {
+    /* user context passed as the first argument to the 4 functions */
+    void *ctx;
+
+    /* allocate a memory block */
+    void* (*malloc) (void *ctx, size_t size);
+
+    /* allocate a memory block initialized by zeros */
+    void* (*calloc) (void *ctx, size_t nelem, size_t elsize);
+
+    /* allocate or resize a memory block */
+    void* (*realloc) (void *ctx, void *ptr, size_t new_size);
+
+    /* release a memory block */
+    void (*free) (void *ctx, void *ptr);
+} PyMemAllocatorEx;
+
+/* Get the memory block allocator of the specified domain. */
+PyAPI_FUNC(void) PyMem_GetAllocator(PyMemAllocatorDomain domain,
+                                    PyMemAllocatorEx *allocator);
+
+/* Set the memory block allocator of the specified domain.
+
+   The new allocator must return a distinct non-NULL pointer when requesting
+   zero bytes.
+
+   For the PYMEM_DOMAIN_RAW domain, the allocator must be thread-safe: the GIL
+   is not held when the allocator is called.
+
+   If the new allocator is not a hook (don't call the previous allocator), the
+   PyMem_SetupDebugHooks() function must be called to reinstall the debug hooks
+   on top on the new allocator. */
+PyAPI_FUNC(void) PyMem_SetAllocator(PyMemAllocatorDomain domain,
+                                    PyMemAllocatorEx *allocator);
+
+/* Setup hooks to detect bugs in the following Python memory allocator
+   functions:
+
+   - PyMem_RawMalloc(), PyMem_RawRealloc(), PyMem_RawFree()
+   - PyMem_Malloc(), PyMem_Realloc(), PyMem_Free()
+   - PyObject_Malloc(), PyObject_Realloc() and PyObject_Free()
+
+   Newly allocated memory is filled with the byte 0xCB, freed memory is filled
+   with the byte 0xDB. Additional checks:
+
+   - detect API violations, ex: PyObject_Free() called on a buffer allocated
+     by PyMem_Malloc()
+   - detect write before the start of the buffer (buffer underflow)
+   - detect write after the end of the buffer (buffer overflow)
+
+   The function does nothing if Python is not compiled is debug mode. */
+PyAPI_FUNC(void) PyMem_SetupDebugHooks(void);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/pystate.h b/contrib/tools/python3/src/Include/cpython/pystate.h
index 5d23d24448..0eb601fd7c 100644
--- a/contrib/tools/python3/src/Include/cpython/pystate.h
+++ b/contrib/tools/python3/src/Include/cpython/pystate.h
@@ -1,261 +1,261 @@
-#ifndef Py_CPYTHON_PYSTATE_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-PyAPI_FUNC(int) _PyInterpreterState_RequiresIDRef(PyInterpreterState *); 
-PyAPI_FUNC(void) _PyInterpreterState_RequireIDRef(PyInterpreterState *, int); 
- 
-PyAPI_FUNC(PyObject *) _PyInterpreterState_GetMainModule(PyInterpreterState *); 
- 
-/* State unique per thread */ 
- 
-/* Py_tracefunc return -1 when raising an exception, or 0 for success. */ 
-typedef int (*Py_tracefunc)(PyObject *, PyFrameObject *, int, PyObject *); 
- 
-/* The following values are used for 'what' for tracefunc functions 
- * 
- * To add a new kind of trace event, also update "trace_init" in 
- * Python/sysmodule.c to define the Python level event name 
- */ 
-#define PyTrace_CALL 0 
-#define PyTrace_EXCEPTION 1 
-#define PyTrace_LINE 2 
-#define PyTrace_RETURN 3 
-#define PyTrace_C_CALL 4 
-#define PyTrace_C_EXCEPTION 5 
-#define PyTrace_C_RETURN 6 
-#define PyTrace_OPCODE 7 
- 
- 
-typedef struct _err_stackitem { 
-    /* This struct represents an entry on the exception stack, which is a 
-     * per-coroutine state. (Coroutine in the computer science sense, 
-     * including the thread and generators). 
-     * This ensures that the exception state is not impacted by "yields" 
-     * from an except handler. 
-     */ 
-    PyObject *exc_type, *exc_value, *exc_traceback; 
- 
-    struct _err_stackitem *previous_item; 
- 
-} _PyErr_StackItem; 
- 
- 
-// The PyThreadState typedef is in Include/pystate.h. 
-struct _ts { 
-    /* See Python/ceval.c for comments explaining most fields */ 
- 
-    struct _ts *prev; 
-    struct _ts *next; 
-    PyInterpreterState *interp; 
- 
-    /* Borrowed reference to the current frame (it can be NULL) */ 
-    PyFrameObject *frame; 
-    int recursion_depth; 
-    char overflowed; /* The stack has overflowed. Allow 50 more calls 
-                        to handle the runtime error. */ 
-    char recursion_critical; /* The current calls must not cause 
-                                a stack overflow. */ 
-    int stackcheck_counter; 
- 
-    /* 'tracing' keeps track of the execution depth when tracing/profiling. 
-       This is to prevent the actual trace/profile code from being recorded in 
-       the trace/profile. */ 
-    int tracing; 
-    int use_tracing; 
- 
-    Py_tracefunc c_profilefunc; 
-    Py_tracefunc c_tracefunc; 
-    PyObject *c_profileobj; 
-    PyObject *c_traceobj; 
- 
-    /* The exception currently being raised */ 
-    PyObject *curexc_type; 
-    PyObject *curexc_value; 
-    PyObject *curexc_traceback; 
- 
-    /* The exception currently being handled, if no coroutines/generators 
-     * are present. Always last element on the stack referred to be exc_info. 
-     */ 
-    _PyErr_StackItem exc_state; 
- 
-    /* Pointer to the top of the stack of the exceptions currently 
-     * being handled */ 
-    _PyErr_StackItem *exc_info; 
- 
-    PyObject *dict;  /* Stores per-thread state */ 
- 
-    int gilstate_counter; 
- 
-    PyObject *async_exc; /* Asynchronous exception to raise */ 
-    unsigned long thread_id; /* Thread id where this tstate was created */ 
- 
-    int trash_delete_nesting; 
-    PyObject *trash_delete_later; 
- 
-    /* Called when a thread state is deleted normally, but not when it 
-     * is destroyed after fork(). 
-     * Pain:  to prevent rare but fatal shutdown errors (issue 18808), 
-     * Thread.join() must wait for the join'ed thread's tstate to be unlinked 
-     * from the tstate chain.  That happens at the end of a thread's life, 
-     * in pystate.c. 
-     * The obvious way doesn't quite work:  create a lock which the tstate 
-     * unlinking code releases, and have Thread.join() wait to acquire that 
-     * lock.  The problem is that we _are_ at the end of the thread's life: 
-     * if the thread holds the last reference to the lock, decref'ing the 
-     * lock will delete the lock, and that may trigger arbitrary Python code 
-     * if there's a weakref, with a callback, to the lock.  But by this time 
-     * _PyRuntime.gilstate.tstate_current is already NULL, so only the simplest 
-     * of C code can be allowed to run (in particular it must not be possible to 
-     * release the GIL). 
-     * So instead of holding the lock directly, the tstate holds a weakref to 
-     * the lock:  that's the value of on_delete_data below.  Decref'ing a 
-     * weakref is harmless. 
-     * on_delete points to _threadmodule.c's static release_sentinel() function. 
-     * After the tstate is unlinked, release_sentinel is called with the 
-     * weakref-to-lock (on_delete_data) argument, and release_sentinel releases 
-     * the indirectly held lock. 
-     */ 
-    void (*on_delete)(void *); 
-    void *on_delete_data; 
- 
-    int coroutine_origin_tracking_depth; 
- 
-    PyObject *async_gen_firstiter; 
-    PyObject *async_gen_finalizer; 
- 
-    PyObject *context; 
-    uint64_t context_ver; 
- 
-    /* Unique thread state id. */ 
-    uint64_t id; 
- 
-    /* XXX signal handlers should also be here */ 
- 
-}; 
- 
-// Alias for backward compatibility with Python 3.8 
-#define _PyInterpreterState_Get PyInterpreterState_Get 
- 
-PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *); 
- 
-/* Similar to PyThreadState_Get(), but don't issue a fatal error 
- * if it is NULL. */ 
-PyAPI_FUNC(PyThreadState *) _PyThreadState_UncheckedGet(void); 
- 
-PyAPI_FUNC(PyObject *) _PyThreadState_GetDict(PyThreadState *tstate); 
- 
-/* PyGILState */ 
- 
-/* Helper/diagnostic function - return 1 if the current thread 
-   currently holds the GIL, 0 otherwise. 
- 
-   The function returns 1 if _PyGILState_check_enabled is non-zero. */ 
-PyAPI_FUNC(int) PyGILState_Check(void); 
- 
-/* Get the single PyInterpreterState used by this process' GILState 
-   implementation. 
- 
-   This function doesn't check for error. Return NULL before _PyGILState_Init() 
-   is called and after _PyGILState_Fini() is called. 
- 
-   See also _PyInterpreterState_Get() and _PyInterpreterState_GET(). */ 
-PyAPI_FUNC(PyInterpreterState *) _PyGILState_GetInterpreterStateUnsafe(void); 
- 
-/* The implementation of sys._current_frames()  Returns a dict mapping 
-   thread id to that thread's current frame. 
-*/ 
-PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void); 
- 
-/* Routines for advanced debuggers, requested by David Beazley. 
-   Don't use unless you know what you are doing! */ 
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Main(void); 
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void); 
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *); 
-PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *); 
-PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *); 
-PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void); 
- 
-/* Frame evaluation API */ 
- 
-typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, PyFrameObject *, int); 
- 
-PyAPI_FUNC(_PyFrameEvalFunction) _PyInterpreterState_GetEvalFrameFunc( 
-    PyInterpreterState *interp); 
-PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc( 
-    PyInterpreterState *interp, 
-    _PyFrameEvalFunction eval_frame); 
- 
-PyAPI_FUNC(const PyConfig*) _PyInterpreterState_GetConfig(PyInterpreterState *interp); 
- 
-// Get the configuration of the currrent interpreter. 
-// The caller must hold the GIL. 
-PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void); 
- 
- 
-/* cross-interpreter data */ 
- 
-struct _xid; 
- 
-// _PyCrossInterpreterData is similar to Py_buffer as an effectively 
-// opaque struct that holds data outside the object machinery.  This 
-// is necessary to pass safely between interpreters in the same process. 
-typedef struct _xid { 
-    // data is the cross-interpreter-safe derivation of a Python object 
-    // (see _PyObject_GetCrossInterpreterData).  It will be NULL if the 
-    // new_object func (below) encodes the data. 
-    void *data; 
-    // obj is the Python object from which the data was derived.  This 
-    // is non-NULL only if the data remains bound to the object in some 
-    // way, such that the object must be "released" (via a decref) when 
-    // the data is released.  In that case the code that sets the field, 
-    // likely a registered "crossinterpdatafunc", is responsible for 
-    // ensuring it owns the reference (i.e. incref). 
-    PyObject *obj; 
-    // interp is the ID of the owning interpreter of the original 
-    // object.  It corresponds to the active interpreter when 
-    // _PyObject_GetCrossInterpreterData() was called.  This should only 
-    // be set by the cross-interpreter machinery. 
-    // 
-    // We use the ID rather than the PyInterpreterState to avoid issues 
-    // with deleted interpreters.  Note that IDs are never re-used, so 
-    // each one will always correspond to a specific interpreter 
-    // (whether still alive or not). 
-    int64_t interp; 
-    // new_object is a function that returns a new object in the current 
-    // interpreter given the data.  The resulting object (a new 
-    // reference) will be equivalent to the original object.  This field 
-    // is required. 
-    PyObject *(*new_object)(struct _xid *); 
-    // free is called when the data is released.  If it is NULL then 
-    // nothing will be done to free the data.  For some types this is 
-    // okay (e.g. bytes) and for those types this field should be set 
-    // to NULL.  However, for most the data was allocated just for 
-    // cross-interpreter use, so it must be freed when 
-    // _PyCrossInterpreterData_Release is called or the memory will 
-    // leak.  In that case, at the very least this field should be set 
-    // to PyMem_RawFree (the default if not explicitly set to NULL). 
-    // The call will happen with the original interpreter activated. 
-    void (*free)(void *); 
-} _PyCrossInterpreterData; 
- 
-PyAPI_FUNC(int) _PyObject_GetCrossInterpreterData(PyObject *, _PyCrossInterpreterData *); 
-PyAPI_FUNC(PyObject *) _PyCrossInterpreterData_NewObject(_PyCrossInterpreterData *); 
-PyAPI_FUNC(void) _PyCrossInterpreterData_Release(_PyCrossInterpreterData *); 
- 
-PyAPI_FUNC(int) _PyObject_CheckCrossInterpreterData(PyObject *); 
- 
-/* cross-interpreter data registry */ 
- 
-typedef int (*crossinterpdatafunc)(PyObject *, struct _xid *); 
- 
-PyAPI_FUNC(int) _PyCrossInterpreterData_RegisterClass(PyTypeObject *, crossinterpdatafunc); 
-PyAPI_FUNC(crossinterpdatafunc) _PyCrossInterpreterData_Lookup(PyObject *); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_PYSTATE_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(int) _PyInterpreterState_RequiresIDRef(PyInterpreterState *);
+PyAPI_FUNC(void) _PyInterpreterState_RequireIDRef(PyInterpreterState *, int);
+
+PyAPI_FUNC(PyObject *) _PyInterpreterState_GetMainModule(PyInterpreterState *);
+
+/* State unique per thread */
+
+/* Py_tracefunc return -1 when raising an exception, or 0 for success. */
+typedef int (*Py_tracefunc)(PyObject *, PyFrameObject *, int, PyObject *);
+
+/* The following values are used for 'what' for tracefunc functions
+ *
+ * To add a new kind of trace event, also update "trace_init" in
+ * Python/sysmodule.c to define the Python level event name
+ */
+#define PyTrace_CALL 0
+#define PyTrace_EXCEPTION 1
+#define PyTrace_LINE 2
+#define PyTrace_RETURN 3
+#define PyTrace_C_CALL 4
+#define PyTrace_C_EXCEPTION 5
+#define PyTrace_C_RETURN 6
+#define PyTrace_OPCODE 7
+
+
+typedef struct _err_stackitem {
+    /* This struct represents an entry on the exception stack, which is a
+     * per-coroutine state. (Coroutine in the computer science sense,
+     * including the thread and generators).
+     * This ensures that the exception state is not impacted by "yields"
+     * from an except handler.
+     */
+    PyObject *exc_type, *exc_value, *exc_traceback;
+
+    struct _err_stackitem *previous_item;
+
+} _PyErr_StackItem;
+
+
+// The PyThreadState typedef is in Include/pystate.h.
+struct _ts {
+    /* See Python/ceval.c for comments explaining most fields */
+
+    struct _ts *prev;
+    struct _ts *next;
+    PyInterpreterState *interp;
+
+    /* Borrowed reference to the current frame (it can be NULL) */
+    PyFrameObject *frame;
+    int recursion_depth;
+    char overflowed; /* The stack has overflowed. Allow 50 more calls
+                        to handle the runtime error. */
+    char recursion_critical; /* The current calls must not cause
+                                a stack overflow. */
+    int stackcheck_counter;
+
+    /* 'tracing' keeps track of the execution depth when tracing/profiling.
+       This is to prevent the actual trace/profile code from being recorded in
+       the trace/profile. */
+    int tracing;
+    int use_tracing;
+
+    Py_tracefunc c_profilefunc;
+    Py_tracefunc c_tracefunc;
+    PyObject *c_profileobj;
+    PyObject *c_traceobj;
+
+    /* The exception currently being raised */
+    PyObject *curexc_type;
+    PyObject *curexc_value;
+    PyObject *curexc_traceback;
+
+    /* The exception currently being handled, if no coroutines/generators
+     * are present. Always last element on the stack referred to be exc_info.
+     */
+    _PyErr_StackItem exc_state;
+
+    /* Pointer to the top of the stack of the exceptions currently
+     * being handled */
+    _PyErr_StackItem *exc_info;
+
+    PyObject *dict;  /* Stores per-thread state */
+
+    int gilstate_counter;
+
+    PyObject *async_exc; /* Asynchronous exception to raise */
+    unsigned long thread_id; /* Thread id where this tstate was created */
+
+    int trash_delete_nesting;
+    PyObject *trash_delete_later;
+
+    /* Called when a thread state is deleted normally, but not when it
+     * is destroyed after fork().
+     * Pain:  to prevent rare but fatal shutdown errors (issue 18808),
+     * Thread.join() must wait for the join'ed thread's tstate to be unlinked
+     * from the tstate chain.  That happens at the end of a thread's life,
+     * in pystate.c.
+     * The obvious way doesn't quite work:  create a lock which the tstate
+     * unlinking code releases, and have Thread.join() wait to acquire that
+     * lock.  The problem is that we _are_ at the end of the thread's life:
+     * if the thread holds the last reference to the lock, decref'ing the
+     * lock will delete the lock, and that may trigger arbitrary Python code
+     * if there's a weakref, with a callback, to the lock.  But by this time
+     * _PyRuntime.gilstate.tstate_current is already NULL, so only the simplest
+     * of C code can be allowed to run (in particular it must not be possible to
+     * release the GIL).
+     * So instead of holding the lock directly, the tstate holds a weakref to
+     * the lock:  that's the value of on_delete_data below.  Decref'ing a
+     * weakref is harmless.
+     * on_delete points to _threadmodule.c's static release_sentinel() function.
+     * After the tstate is unlinked, release_sentinel is called with the
+     * weakref-to-lock (on_delete_data) argument, and release_sentinel releases
+     * the indirectly held lock.
+     */
+    void (*on_delete)(void *);
+    void *on_delete_data;
+
+    int coroutine_origin_tracking_depth;
+
+    PyObject *async_gen_firstiter;
+    PyObject *async_gen_finalizer;
+
+    PyObject *context;
+    uint64_t context_ver;
+
+    /* Unique thread state id. */
+    uint64_t id;
+
+    /* XXX signal handlers should also be here */
+
+};
+
+// Alias for backward compatibility with Python 3.8
+#define _PyInterpreterState_Get PyInterpreterState_Get
+
+PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *);
+
+/* Similar to PyThreadState_Get(), but don't issue a fatal error
+ * if it is NULL. */
+PyAPI_FUNC(PyThreadState *) _PyThreadState_UncheckedGet(void);
+
+PyAPI_FUNC(PyObject *) _PyThreadState_GetDict(PyThreadState *tstate);
+
+/* PyGILState */
+
+/* Helper/diagnostic function - return 1 if the current thread
+   currently holds the GIL, 0 otherwise.
+
+   The function returns 1 if _PyGILState_check_enabled is non-zero. */
+PyAPI_FUNC(int) PyGILState_Check(void);
+
+/* Get the single PyInterpreterState used by this process' GILState
+   implementation.
+
+   This function doesn't check for error. Return NULL before _PyGILState_Init()
+   is called and after _PyGILState_Fini() is called.
+
+   See also _PyInterpreterState_Get() and _PyInterpreterState_GET(). */
+PyAPI_FUNC(PyInterpreterState *) _PyGILState_GetInterpreterStateUnsafe(void);
+
+/* The implementation of sys._current_frames()  Returns a dict mapping
+   thread id to that thread's current frame.
+*/
+PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void);
+
+/* Routines for advanced debuggers, requested by David Beazley.
+   Don't use unless you know what you are doing! */
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Main(void);
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void);
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *);
+PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *);
+PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *);
+PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
+
+/* Frame evaluation API */
+
+typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, PyFrameObject *, int);
+
+PyAPI_FUNC(_PyFrameEvalFunction) _PyInterpreterState_GetEvalFrameFunc(
+    PyInterpreterState *interp);
+PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc(
+    PyInterpreterState *interp,
+    _PyFrameEvalFunction eval_frame);
+
+PyAPI_FUNC(const PyConfig*) _PyInterpreterState_GetConfig(PyInterpreterState *interp);
+
+// Get the configuration of the currrent interpreter.
+// The caller must hold the GIL.
+PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void);
+
+
+/* cross-interpreter data */
+
+struct _xid;
+
+// _PyCrossInterpreterData is similar to Py_buffer as an effectively
+// opaque struct that holds data outside the object machinery.  This
+// is necessary to pass safely between interpreters in the same process.
+typedef struct _xid {
+    // data is the cross-interpreter-safe derivation of a Python object
+    // (see _PyObject_GetCrossInterpreterData).  It will be NULL if the
+    // new_object func (below) encodes the data.
+    void *data;
+    // obj is the Python object from which the data was derived.  This
+    // is non-NULL only if the data remains bound to the object in some
+    // way, such that the object must be "released" (via a decref) when
+    // the data is released.  In that case the code that sets the field,
+    // likely a registered "crossinterpdatafunc", is responsible for
+    // ensuring it owns the reference (i.e. incref).
+    PyObject *obj;
+    // interp is the ID of the owning interpreter of the original
+    // object.  It corresponds to the active interpreter when
+    // _PyObject_GetCrossInterpreterData() was called.  This should only
+    // be set by the cross-interpreter machinery.
+    //
+    // We use the ID rather than the PyInterpreterState to avoid issues
+    // with deleted interpreters.  Note that IDs are never re-used, so
+    // each one will always correspond to a specific interpreter
+    // (whether still alive or not).
+    int64_t interp;
+    // new_object is a function that returns a new object in the current
+    // interpreter given the data.  The resulting object (a new
+    // reference) will be equivalent to the original object.  This field
+    // is required.
+    PyObject *(*new_object)(struct _xid *);
+    // free is called when the data is released.  If it is NULL then
+    // nothing will be done to free the data.  For some types this is
+    // okay (e.g. bytes) and for those types this field should be set
+    // to NULL.  However, for most the data was allocated just for
+    // cross-interpreter use, so it must be freed when
+    // _PyCrossInterpreterData_Release is called or the memory will
+    // leak.  In that case, at the very least this field should be set
+    // to PyMem_RawFree (the default if not explicitly set to NULL).
+    // The call will happen with the original interpreter activated.
+    void (*free)(void *);
+} _PyCrossInterpreterData;
+
+PyAPI_FUNC(int) _PyObject_GetCrossInterpreterData(PyObject *, _PyCrossInterpreterData *);
+PyAPI_FUNC(PyObject *) _PyCrossInterpreterData_NewObject(_PyCrossInterpreterData *);
+PyAPI_FUNC(void) _PyCrossInterpreterData_Release(_PyCrossInterpreterData *);
+
+PyAPI_FUNC(int) _PyObject_CheckCrossInterpreterData(PyObject *);
+
+/* cross-interpreter data registry */
+
+typedef int (*crossinterpdatafunc)(PyObject *, struct _xid *);
+
+PyAPI_FUNC(int) _PyCrossInterpreterData_RegisterClass(PyTypeObject *, crossinterpdatafunc);
+PyAPI_FUNC(crossinterpdatafunc) _PyCrossInterpreterData_Lookup(PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/sysmodule.h b/contrib/tools/python3/src/Include/cpython/sysmodule.h
index f647940974..1802b5b300 100644
--- a/contrib/tools/python3/src/Include/cpython/sysmodule.h
+++ b/contrib/tools/python3/src/Include/cpython/sysmodule.h
@@ -1,24 +1,24 @@
-#ifndef Py_CPYTHON_SYSMODULE_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-PyAPI_FUNC(PyObject *) _PySys_GetObjectId(_Py_Identifier *key); 
-PyAPI_FUNC(int) _PySys_SetObjectId(_Py_Identifier *key, PyObject *); 
- 
-PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *); 
- 
-typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *); 
- 
-PyAPI_FUNC(int) PySys_Audit( 
-    const char *event, 
-    const char *argFormat, 
-    ...); 
-PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_SYSMODULE_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(PyObject *) _PySys_GetObjectId(_Py_Identifier *key);
+PyAPI_FUNC(int) _PySys_SetObjectId(_Py_Identifier *key, PyObject *);
+
+PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *);
+
+typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *);
+
+PyAPI_FUNC(int) PySys_Audit(
+    const char *event,
+    const char *argFormat,
+    ...);
+PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/traceback.h b/contrib/tools/python3/src/Include/cpython/traceback.h
index 3e26e04a09..837470c3ba 100644
--- a/contrib/tools/python3/src/Include/cpython/traceback.h
+++ b/contrib/tools/python3/src/Include/cpython/traceback.h
@@ -1,22 +1,22 @@
-#ifndef Py_CPYTHON_TRACEBACK_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-typedef struct _traceback { 
-    PyObject_HEAD 
-    struct _traceback *tb_next; 
-    PyFrameObject *tb_frame; 
-    int tb_lasti; 
-    int tb_lineno; 
-} PyTracebackObject; 
- 
-PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int); 
-PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_TRACEBACK_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _traceback {
+    PyObject_HEAD
+    struct _traceback *tb_next;
+    PyFrameObject *tb_frame;
+    int tb_lasti;
+    int tb_lineno;
+} PyTracebackObject;
+
+PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int);
+PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/tupleobject.h b/contrib/tools/python3/src/Include/cpython/tupleobject.h
index f66628675c..1565f2a5c3 100644
--- a/contrib/tools/python3/src/Include/cpython/tupleobject.h
+++ b/contrib/tools/python3/src/Include/cpython/tupleobject.h
@@ -1,36 +1,36 @@
-#ifndef Py_CPYTHON_TUPLEOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-typedef struct { 
-    PyObject_VAR_HEAD 
-    /* ob_item contains space for 'ob_size' elements. 
-       Items must normally not be NULL, except during construction when 
-       the tuple is not yet visible outside the function that builds it. */ 
-    PyObject *ob_item[1]; 
-} PyTupleObject; 
- 
-PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); 
-PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *); 
- 
-/* Macros trading safety for speed */ 
- 
-/* Cast argument to PyTupleObject* type. */ 
-#define _PyTuple_CAST(op) (assert(PyTuple_Check(op)), (PyTupleObject *)(op)) 
- 
-#define PyTuple_GET_SIZE(op)    Py_SIZE(_PyTuple_CAST(op)) 
- 
-#define PyTuple_GET_ITEM(op, i) (_PyTuple_CAST(op)->ob_item[i]) 
- 
-/* Macro, *only* to be used to fill in brand new tuples */ 
-#define PyTuple_SET_ITEM(op, i, v) (_PyTuple_CAST(op)->ob_item[i] = v) 
- 
-PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_TUPLEOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_VAR_HEAD
+    /* ob_item contains space for 'ob_size' elements.
+       Items must normally not be NULL, except during construction when
+       the tuple is not yet visible outside the function that builds it. */
+    PyObject *ob_item[1];
+} PyTupleObject;
+
+PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t);
+PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *);
+
+/* Macros trading safety for speed */
+
+/* Cast argument to PyTupleObject* type. */
+#define _PyTuple_CAST(op) (assert(PyTuple_Check(op)), (PyTupleObject *)(op))
+
+#define PyTuple_GET_SIZE(op)    Py_SIZE(_PyTuple_CAST(op))
+
+#define PyTuple_GET_ITEM(op, i) (_PyTuple_CAST(op)->ob_item[i])
+
+/* Macro, *only* to be used to fill in brand new tuples */
+#define PyTuple_SET_ITEM(op, i, v) (_PyTuple_CAST(op)->ob_item[i] = v)
+
+PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/contrib/tools/python3/src/Include/cpython/unicodeobject.h b/contrib/tools/python3/src/Include/cpython/unicodeobject.h
index c6dca2e3ec..1b460c9f18 100644
--- a/contrib/tools/python3/src/Include/cpython/unicodeobject.h
+++ b/contrib/tools/python3/src/Include/cpython/unicodeobject.h
@@ -1,1237 +1,1237 @@
-#ifndef Py_CPYTHON_UNICODEOBJECT_H 
-#  error "this header file must not be included directly" 
-#endif 
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-/* Py_UNICODE was the native Unicode storage format (code unit) used by 
-   Python and represents a single Unicode element in the Unicode type. 
-   With PEP 393, Py_UNICODE is deprecated and replaced with a 
-   typedef to wchar_t. */ 
-#define PY_UNICODE_TYPE wchar_t 
-/* Py_DEPRECATED(3.3) */ typedef wchar_t Py_UNICODE; 
- 
-/* --- Internal Unicode Operations ---------------------------------------- */ 
- 
-/* Since splitting on whitespace is an important use case, and 
-   whitespace in most situations is solely ASCII whitespace, we 
-   optimize for the common case by using a quick look-up table 
-   _Py_ascii_whitespace (see below) with an inlined check. 
- 
- */ 
-#define Py_UNICODE_ISSPACE(ch) \ 
-    ((Py_UCS4)(ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch)) 
- 
-#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch) 
-#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch) 
-#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch) 
-#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch) 
- 
-#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch) 
-#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch) 
-#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch) 
- 
-#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch) 
-#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch) 
-#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch) 
-#define Py_UNICODE_ISPRINTABLE(ch) _PyUnicode_IsPrintable(ch) 
- 
-#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch) 
-#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch) 
-#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch) 
- 
-#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch) 
- 
-#define Py_UNICODE_ISALNUM(ch) \ 
-       (Py_UNICODE_ISALPHA(ch) || \ 
-    Py_UNICODE_ISDECIMAL(ch) || \ 
-    Py_UNICODE_ISDIGIT(ch) || \ 
-    Py_UNICODE_ISNUMERIC(ch)) 
- 
-Py_DEPRECATED(3.3) static inline void 
-Py_UNICODE_COPY(Py_UNICODE *target, const Py_UNICODE *source, Py_ssize_t length) { 
-    memcpy(target, source, (size_t)(length) * sizeof(Py_UNICODE)); 
-} 
- 
-Py_DEPRECATED(3.3) static inline void 
-Py_UNICODE_FILL(Py_UNICODE *target, Py_UNICODE value, Py_ssize_t length) { 
-    Py_ssize_t i; 
-    for (i = 0; i < length; i++) { 
-        target[i] = value; 
-    } 
-} 
- 
-/* macros to work with surrogates */ 
-#define Py_UNICODE_IS_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDFFF) 
-#define Py_UNICODE_IS_HIGH_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDBFF) 
-#define Py_UNICODE_IS_LOW_SURROGATE(ch) (0xDC00 <= (ch) && (ch) <= 0xDFFF) 
-/* Join two surrogate characters and return a single Py_UCS4 value. */ 
-#define Py_UNICODE_JOIN_SURROGATES(high, low)  \ 
-    (((((Py_UCS4)(high) & 0x03FF) << 10) |      \ 
-      ((Py_UCS4)(low) & 0x03FF)) + 0x10000) 
-/* high surrogate = top 10 bits added to D800 */ 
-#define Py_UNICODE_HIGH_SURROGATE(ch) (0xD800 - (0x10000 >> 10) + ((ch) >> 10)) 
-/* low surrogate = bottom 10 bits added to DC00 */ 
-#define Py_UNICODE_LOW_SURROGATE(ch) (0xDC00 + ((ch) & 0x3FF)) 
- 
-/* --- Unicode Type ------------------------------------------------------- */ 
- 
-/* ASCII-only strings created through PyUnicode_New use the PyASCIIObject 
-   structure. state.ascii and state.compact are set, and the data 
-   immediately follow the structure. utf8_length and wstr_length can be found 
-   in the length field; the utf8 pointer is equal to the data pointer. */ 
-typedef struct { 
-    /* There are 4 forms of Unicode strings: 
- 
-       - compact ascii: 
- 
-         * structure = PyASCIIObject 
-         * test: PyUnicode_IS_COMPACT_ASCII(op) 
-         * kind = PyUnicode_1BYTE_KIND 
-         * compact = 1 
-         * ascii = 1 
-         * ready = 1 
-         * (length is the length of the utf8 and wstr strings) 
-         * (data starts just after the structure) 
-         * (since ASCII is decoded from UTF-8, the utf8 string are the data) 
- 
-       - compact: 
- 
-         * structure = PyCompactUnicodeObject 
-         * test: PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op) 
-         * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or 
-           PyUnicode_4BYTE_KIND 
-         * compact = 1 
-         * ready = 1 
-         * ascii = 0 
-         * utf8 is not shared with data 
-         * utf8_length = 0 if utf8 is NULL 
-         * wstr is shared with data and wstr_length=length 
-           if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2 
-           or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_t)=4 
-         * wstr_length = 0 if wstr is NULL 
-         * (data starts just after the structure) 
- 
-       - legacy string, not ready: 
- 
-         * structure = PyUnicodeObject 
-         * test: kind == PyUnicode_WCHAR_KIND 
-         * length = 0 (use wstr_length) 
-         * hash = -1 
-         * kind = PyUnicode_WCHAR_KIND 
-         * compact = 0 
-         * ascii = 0 
-         * ready = 0 
-         * interned = SSTATE_NOT_INTERNED 
-         * wstr is not NULL 
-         * data.any is NULL 
-         * utf8 is NULL 
-         * utf8_length = 0 
- 
-       - legacy string, ready: 
- 
-         * structure = PyUnicodeObject structure 
-         * test: !PyUnicode_IS_COMPACT(op) && kind != PyUnicode_WCHAR_KIND 
-         * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or 
-           PyUnicode_4BYTE_KIND 
-         * compact = 0 
-         * ready = 1 
-         * data.any is not NULL 
-         * utf8 is shared and utf8_length = length with data.any if ascii = 1 
-         * utf8_length = 0 if utf8 is NULL 
-         * wstr is shared with data.any and wstr_length = length 
-           if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2 
-           or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_4)=4 
-         * wstr_length = 0 if wstr is NULL 
- 
-       Compact strings use only one memory block (structure + characters), 
-       whereas legacy strings use one block for the structure and one block 
-       for characters. 
- 
-       Legacy strings are created by PyUnicode_FromUnicode() and 
-       PyUnicode_FromStringAndSize(NULL, size) functions. They become ready 
-       when PyUnicode_READY() is called. 
- 
-       See also _PyUnicode_CheckConsistency(). 
-    */ 
-    PyObject_HEAD 
-    Py_ssize_t length;          /* Number of code points in the string */ 
-    Py_hash_t hash;             /* Hash value; -1 if not set */ 
-    struct { 
-        /* 
-           SSTATE_NOT_INTERNED (0) 
-           SSTATE_INTERNED_MORTAL (1) 
-           SSTATE_INTERNED_IMMORTAL (2) 
- 
-           If interned != SSTATE_NOT_INTERNED, the two references from the 
-           dictionary to this object are *not* counted in ob_refcnt. 
-         */ 
-        unsigned int interned:2; 
-        /* Character size: 
- 
-           - PyUnicode_WCHAR_KIND (0): 
- 
-             * character type = wchar_t (16 or 32 bits, depending on the 
-               platform) 
- 
-           - PyUnicode_1BYTE_KIND (1): 
- 
-             * character type = Py_UCS1 (8 bits, unsigned) 
-             * all characters are in the range U+0000-U+00FF (latin1) 
-             * if ascii is set, all characters are in the range U+0000-U+007F 
-               (ASCII), otherwise at least one character is in the range 
-               U+0080-U+00FF 
- 
-           - PyUnicode_2BYTE_KIND (2): 
- 
-             * character type = Py_UCS2 (16 bits, unsigned) 
-             * all characters are in the range U+0000-U+FFFF (BMP) 
-             * at least one character is in the range U+0100-U+FFFF 
- 
-           - PyUnicode_4BYTE_KIND (4): 
- 
-             * character type = Py_UCS4 (32 bits, unsigned) 
-             * all characters are in the range U+0000-U+10FFFF 
-             * at least one character is in the range U+10000-U+10FFFF 
-         */ 
-        unsigned int kind:3; 
-        /* Compact is with respect to the allocation scheme. Compact unicode 
-           objects only require one memory block while non-compact objects use 
-           one block for the PyUnicodeObject struct and another for its data 
-           buffer. */ 
-        unsigned int compact:1; 
-        /* The string only contains characters in the range U+0000-U+007F (ASCII) 
-           and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is 
-           set, use the PyASCIIObject structure. */ 
-        unsigned int ascii:1; 
-        /* The ready flag indicates whether the object layout is initialized 
-           completely. This means that this is either a compact object, or 
-           the data pointer is filled out. The bit is redundant, and helps 
-           to minimize the test in PyUnicode_IS_READY(). */ 
-        unsigned int ready:1; 
-        /* Padding to ensure that PyUnicode_DATA() is always aligned to 
-           4 bytes (see issue #19537 on m68k). */ 
-        unsigned int :24; 
-    } state; 
-    wchar_t *wstr;              /* wchar_t representation (null-terminated) */ 
-} PyASCIIObject; 
- 
-/* Non-ASCII strings allocated through PyUnicode_New use the 
-   PyCompactUnicodeObject structure. state.compact is set, and the data 
-   immediately follow the structure. */ 
-typedef struct { 
-    PyASCIIObject _base; 
-    Py_ssize_t utf8_length;     /* Number of bytes in utf8, excluding the 
-                                 * terminating \0. */ 
-    char *utf8;                 /* UTF-8 representation (null-terminated) */ 
-    Py_ssize_t wstr_length;     /* Number of code points in wstr, possible 
-                                 * surrogates count as two code points. */ 
-} PyCompactUnicodeObject; 
- 
-/* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the 
-   PyUnicodeObject structure. The actual string data is initially in the wstr 
-   block, and copied into the data block using _PyUnicode_Ready. */ 
-typedef struct { 
-    PyCompactUnicodeObject _base; 
-    union { 
-        void *any; 
-        Py_UCS1 *latin1; 
-        Py_UCS2 *ucs2; 
-        Py_UCS4 *ucs4; 
-    } data;                     /* Canonical, smallest-form Unicode buffer */ 
-} PyUnicodeObject; 
- 
-PyAPI_FUNC(int) _PyUnicode_CheckConsistency( 
-    PyObject *op, 
-    int check_content); 
- 
-/* Fast access macros */ 
- 
-/* Returns the deprecated Py_UNICODE representation's size in code units 
-   (this includes surrogate pairs as 2 units). 
-   If the Py_UNICODE representation is not available, it will be computed 
-   on request.  Use PyUnicode_GET_LENGTH() for the length in code points. */ 
- 
-/* Py_DEPRECATED(3.3) */ 
-#define PyUnicode_GET_SIZE(op)                       \ 
-    (assert(PyUnicode_Check(op)),                    \ 
-     (((PyASCIIObject *)(op))->wstr) ?               \ 
-      PyUnicode_WSTR_LENGTH(op) :                    \ 
-      ((void)PyUnicode_AsUnicode(_PyObject_CAST(op)),\ 
-       assert(((PyASCIIObject *)(op))->wstr),        \ 
-       PyUnicode_WSTR_LENGTH(op))) 
- 
-/* Py_DEPRECATED(3.3) */ 
-#define PyUnicode_GET_DATA_SIZE(op) \ 
-    (PyUnicode_GET_SIZE(op) * Py_UNICODE_SIZE) 
- 
-/* Alias for PyUnicode_AsUnicode().  This will create a wchar_t/Py_UNICODE 
-   representation on demand.  Using this macro is very inefficient now, 
-   try to port your code to use the new PyUnicode_*BYTE_DATA() macros or 
-   use PyUnicode_WRITE() and PyUnicode_READ(). */ 
- 
-/* Py_DEPRECATED(3.3) */ 
-#define PyUnicode_AS_UNICODE(op) \ 
-    (assert(PyUnicode_Check(op)), \ 
-     (((PyASCIIObject *)(op))->wstr) ? (((PyASCIIObject *)(op))->wstr) : \ 
-      PyUnicode_AsUnicode(_PyObject_CAST(op))) 
- 
-/* Py_DEPRECATED(3.3) */ 
-#define PyUnicode_AS_DATA(op) \ 
-    ((const char *)(PyUnicode_AS_UNICODE(op))) 
- 
- 
-/* --- Flexible String Representation Helper Macros (PEP 393) -------------- */ 
- 
-/* Values for PyASCIIObject.state: */ 
- 
-/* Interning state. */ 
-#define SSTATE_NOT_INTERNED 0 
-#define SSTATE_INTERNED_MORTAL 1 
-#define SSTATE_INTERNED_IMMORTAL 2 
- 
-/* Return true if the string contains only ASCII characters, or 0 if not. The 
-   string may be compact (PyUnicode_IS_COMPACT_ASCII) or not, but must be 
-   ready. */ 
-#define PyUnicode_IS_ASCII(op)                   \ 
-    (assert(PyUnicode_Check(op)),                \ 
-     assert(PyUnicode_IS_READY(op)),             \ 
-     ((PyASCIIObject*)op)->state.ascii) 
- 
-/* Return true if the string is compact or 0 if not. 
-   No type checks or Ready calls are performed. */ 
-#define PyUnicode_IS_COMPACT(op) \ 
-    (((PyASCIIObject*)(op))->state.compact) 
- 
-/* Return true if the string is a compact ASCII string (use PyASCIIObject 
-   structure), or 0 if not.  No type checks or Ready calls are performed. */ 
-#define PyUnicode_IS_COMPACT_ASCII(op)                 \ 
-    (((PyASCIIObject*)op)->state.ascii && PyUnicode_IS_COMPACT(op)) 
- 
-enum PyUnicode_Kind { 
-/* String contains only wstr byte characters.  This is only possible 
-   when the string was created with a legacy API and _PyUnicode_Ready() 
-   has not been called yet.  */ 
-    PyUnicode_WCHAR_KIND = 0, 
-/* Return values of the PyUnicode_KIND() macro: */ 
-    PyUnicode_1BYTE_KIND = 1, 
-    PyUnicode_2BYTE_KIND = 2, 
-    PyUnicode_4BYTE_KIND = 4 
-}; 
- 
-/* Return pointers to the canonical representation cast to unsigned char, 
-   Py_UCS2, or Py_UCS4 for direct character access. 
-   No checks are performed, use PyUnicode_KIND() before to ensure 
-   these will work correctly. */ 
- 
-#define PyUnicode_1BYTE_DATA(op) ((Py_UCS1*)PyUnicode_DATA(op)) 
-#define PyUnicode_2BYTE_DATA(op) ((Py_UCS2*)PyUnicode_DATA(op)) 
-#define PyUnicode_4BYTE_DATA(op) ((Py_UCS4*)PyUnicode_DATA(op)) 
- 
-/* Return one of the PyUnicode_*_KIND values defined above. */ 
-#define PyUnicode_KIND(op) \ 
-    (assert(PyUnicode_Check(op)), \ 
-     assert(PyUnicode_IS_READY(op)),            \ 
-     ((PyASCIIObject *)(op))->state.kind) 
- 
-/* Return a void pointer to the raw unicode buffer. */ 
-#define _PyUnicode_COMPACT_DATA(op)                     \ 
-    (PyUnicode_IS_ASCII(op) ?                   \ 
-     ((void*)((PyASCIIObject*)(op) + 1)) :              \ 
-     ((void*)((PyCompactUnicodeObject*)(op) + 1))) 
- 
-#define _PyUnicode_NONCOMPACT_DATA(op)                  \ 
-    (assert(((PyUnicodeObject*)(op))->data.any),        \ 
-     ((((PyUnicodeObject *)(op))->data.any))) 
- 
-#define PyUnicode_DATA(op) \ 
-    (assert(PyUnicode_Check(op)), \ 
-     PyUnicode_IS_COMPACT(op) ? _PyUnicode_COMPACT_DATA(op) :   \ 
-     _PyUnicode_NONCOMPACT_DATA(op)) 
- 
-/* In the access macros below, "kind" may be evaluated more than once. 
-   All other macro parameters are evaluated exactly once, so it is safe 
-   to put side effects into them (such as increasing the index). */ 
- 
-/* Write into the canonical representation, this macro does not do any sanity 
-   checks and is intended for usage in loops.  The caller should cache the 
-   kind and data pointers obtained from other macro calls. 
-   index is the index in the string (starts at 0) and value is the new 
-   code point value which should be written to that location. */ 
-#define PyUnicode_WRITE(kind, data, index, value) \ 
-    do { \ 
-        switch ((kind)) { \ 
-        case PyUnicode_1BYTE_KIND: { \ 
-            ((Py_UCS1 *)(data))[(index)] = (Py_UCS1)(value); \ 
-            break; \ 
-        } \ 
-        case PyUnicode_2BYTE_KIND: { \ 
-            ((Py_UCS2 *)(data))[(index)] = (Py_UCS2)(value); \ 
-            break; \ 
-        } \ 
-        default: { \ 
-            assert((kind) == PyUnicode_4BYTE_KIND); \ 
-            ((Py_UCS4 *)(data))[(index)] = (Py_UCS4)(value); \ 
-        } \ 
-        } \ 
-    } while (0) 
- 
-/* Read a code point from the string's canonical representation.  No checks 
-   or ready calls are performed. */ 
-#define PyUnicode_READ(kind, data, index) \ 
-    ((Py_UCS4) \ 
-    ((kind) == PyUnicode_1BYTE_KIND ? \ 
-        ((const Py_UCS1 *)(data))[(index)] : \ 
-        ((kind) == PyUnicode_2BYTE_KIND ? \ 
-            ((const Py_UCS2 *)(data))[(index)] : \ 
-            ((const Py_UCS4 *)(data))[(index)] \ 
-        ) \ 
-    )) 
- 
-/* PyUnicode_READ_CHAR() is less efficient than PyUnicode_READ() because it 
-   calls PyUnicode_KIND() and might call it twice.  For single reads, use 
-   PyUnicode_READ_CHAR, for multiple consecutive reads callers should 
-   cache kind and use PyUnicode_READ instead. */ 
-#define PyUnicode_READ_CHAR(unicode, index) \ 
-    (assert(PyUnicode_Check(unicode)),          \ 
-     assert(PyUnicode_IS_READY(unicode)),       \ 
-     (Py_UCS4)                                  \ 
-        (PyUnicode_KIND((unicode)) == PyUnicode_1BYTE_KIND ? \ 
-            ((const Py_UCS1 *)(PyUnicode_DATA((unicode))))[(index)] : \ 
-            (PyUnicode_KIND((unicode)) == PyUnicode_2BYTE_KIND ? \ 
-                ((const Py_UCS2 *)(PyUnicode_DATA((unicode))))[(index)] : \ 
-                ((const Py_UCS4 *)(PyUnicode_DATA((unicode))))[(index)] \ 
-            ) \ 
-        )) 
- 
-/* Returns the length of the unicode string. The caller has to make sure that 
-   the string has it's canonical representation set before calling 
-   this macro.  Call PyUnicode_(FAST_)Ready to ensure that. */ 
-#define PyUnicode_GET_LENGTH(op)                \ 
-    (assert(PyUnicode_Check(op)),               \ 
-     assert(PyUnicode_IS_READY(op)),            \ 
-     ((PyASCIIObject *)(op))->length) 
- 
- 
-/* Fast check to determine whether an object is ready. Equivalent to 
-   PyUnicode_IS_COMPACT(op) || ((PyUnicodeObject*)(op))->data.any */ 
- 
-#define PyUnicode_IS_READY(op) (((PyASCIIObject*)op)->state.ready) 
- 
-/* PyUnicode_READY() does less work than _PyUnicode_Ready() in the best 
-   case.  If the canonical representation is not yet set, it will still call 
-   _PyUnicode_Ready(). 
-   Returns 0 on success and -1 on errors. */ 
-#define PyUnicode_READY(op)                        \ 
-    (assert(PyUnicode_Check(op)),                       \ 
-     (PyUnicode_IS_READY(op) ?                          \ 
-      0 : _PyUnicode_Ready(_PyObject_CAST(op)))) 
- 
-/* Return a maximum character value which is suitable for creating another 
-   string based on op.  This is always an approximation but more efficient 
-   than iterating over the string. */ 
-#define PyUnicode_MAX_CHAR_VALUE(op) \ 
-    (assert(PyUnicode_IS_READY(op)),                                    \ 
-     (PyUnicode_IS_ASCII(op) ?                                          \ 
-      (0x7f) :                                                          \ 
-      (PyUnicode_KIND(op) == PyUnicode_1BYTE_KIND ?                     \ 
-       (0xffU) :                                                        \ 
-       (PyUnicode_KIND(op) == PyUnicode_2BYTE_KIND ?                    \ 
-        (0xffffU) :                                                     \ 
-        (0x10ffffU))))) 
- 
-Py_DEPRECATED(3.3) 
-static inline Py_ssize_t _PyUnicode_get_wstr_length(PyObject *op) { 
-    return PyUnicode_IS_COMPACT_ASCII(op) ? 
-            ((PyASCIIObject*)op)->length : 
-            ((PyCompactUnicodeObject*)op)->wstr_length; 
-} 
-#define PyUnicode_WSTR_LENGTH(op) _PyUnicode_get_wstr_length((PyObject*)op) 
- 
-/* === Public API ========================================================= */ 
- 
-/* --- Plain Py_UNICODE --------------------------------------------------- */ 
- 
-/* With PEP 393, this is the recommended way to allocate a new unicode object. 
-   This function will allocate the object and its buffer in a single memory 
-   block.  Objects created using this function are not resizable. */ 
-PyAPI_FUNC(PyObject*) PyUnicode_New( 
-    Py_ssize_t size,            /* Number of code points in the new string */ 
-    Py_UCS4 maxchar             /* maximum code point value in the string */ 
-    ); 
- 
-/* Initializes the canonical string representation from the deprecated 
-   wstr/Py_UNICODE representation. This function is used to convert Unicode 
-   objects which were created using the old API to the new flexible format 
-   introduced with PEP 393. 
- 
-   Don't call this function directly, use the public PyUnicode_READY() macro 
-   instead. */ 
-PyAPI_FUNC(int) _PyUnicode_Ready( 
-    PyObject *unicode           /* Unicode object */ 
-    ); 
- 
-/* Get a copy of a Unicode string. */ 
-PyAPI_FUNC(PyObject*) _PyUnicode_Copy( 
-    PyObject *unicode 
-    ); 
- 
-/* Copy character from one unicode object into another, this function performs 
-   character conversion when necessary and falls back to memcpy() if possible. 
- 
-   Fail if to is too small (smaller than *how_many* or smaller than 
-   len(from)-from_start), or if kind(from[from_start:from_start+how_many]) > 
-   kind(to), or if *to* has more than 1 reference. 
- 
-   Return the number of written character, or return -1 and raise an exception 
-   on error. 
- 
-   Pseudo-code: 
- 
-       how_many = min(how_many, len(from) - from_start) 
-       to[to_start:to_start+how_many] = from[from_start:from_start+how_many] 
-       return how_many 
- 
-   Note: The function doesn't write a terminating null character. 
-   */ 
-PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters( 
-    PyObject *to, 
-    Py_ssize_t to_start, 
-    PyObject *from, 
-    Py_ssize_t from_start, 
-    Py_ssize_t how_many 
-    ); 
- 
-/* Unsafe version of PyUnicode_CopyCharacters(): don't check arguments and so 
-   may crash if parameters are invalid (e.g. if the output string 
-   is too short). */ 
-PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters( 
-    PyObject *to, 
-    Py_ssize_t to_start, 
-    PyObject *from, 
-    Py_ssize_t from_start, 
-    Py_ssize_t how_many 
-    ); 
- 
-/* Fill a string with a character: write fill_char into 
-   unicode[start:start+length]. 
- 
-   Fail if fill_char is bigger than the string maximum character, or if the 
-   string has more than 1 reference. 
- 
-   Return the number of written character, or return -1 and raise an exception 
-   on error. */ 
-PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill( 
-    PyObject *unicode, 
-    Py_ssize_t start, 
-    Py_ssize_t length, 
-    Py_UCS4 fill_char 
-    ); 
- 
-/* Unsafe version of PyUnicode_Fill(): don't check arguments and so may crash 
-   if parameters are invalid (e.g. if length is longer than the string). */ 
-PyAPI_FUNC(void) _PyUnicode_FastFill( 
-    PyObject *unicode, 
-    Py_ssize_t start, 
-    Py_ssize_t length, 
-    Py_UCS4 fill_char 
-    ); 
- 
-/* Create a Unicode Object from the Py_UNICODE buffer u of the given 
-   size. 
- 
-   u may be NULL which causes the contents to be undefined. It is the 
-   user's responsibility to fill in the needed data afterwards. Note 
-   that modifying the Unicode object contents after construction is 
-   only allowed if u was set to NULL. 
- 
-   The buffer is copied into the new object. */ 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode( 
-    const Py_UNICODE *u,        /* Unicode buffer */ 
-    Py_ssize_t size             /* size of buffer */ 
-    ); 
- 
-/* Create a new string from a buffer of Py_UCS1, Py_UCS2 or Py_UCS4 characters. 
-   Scan the string to find the maximum character. */ 
-PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData( 
-    int kind, 
-    const void *buffer, 
-    Py_ssize_t size); 
- 
-/* Create a new string from a buffer of ASCII characters. 
-   WARNING: Don't check if the string contains any non-ASCII character. */ 
-PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII( 
-    const char *buffer, 
-    Py_ssize_t size); 
- 
-/* Compute the maximum character of the substring unicode[start:end]. 
-   Return 127 for an empty string. */ 
-PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar ( 
-    PyObject *unicode, 
-    Py_ssize_t start, 
-    Py_ssize_t end); 
- 
-/* Return a read-only pointer to the Unicode object's internal 
-   Py_UNICODE buffer. 
-   If the wchar_t/Py_UNICODE representation is not yet available, this 
-   function will calculate it. */ 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode( 
-    PyObject *unicode           /* Unicode object */ 
-    ); 
- 
-/* Similar to PyUnicode_AsUnicode(), but raises a ValueError if the string 
-   contains null characters. */ 
-Py_DEPRECATED(3.3) PyAPI_FUNC(const Py_UNICODE *) _PyUnicode_AsUnicode( 
-    PyObject *unicode           /* Unicode object */ 
-    ); 
- 
-/* Return a read-only pointer to the Unicode object's internal 
-   Py_UNICODE buffer and save the length at size. 
-   If the wchar_t/Py_UNICODE representation is not yet available, this 
-   function will calculate it. */ 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize( 
-    PyObject *unicode,          /* Unicode object */ 
-    Py_ssize_t *size            /* location where to save the length */ 
-    ); 
- 
-/* Get the maximum ordinal for a Unicode character. */ 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void); 
- 
- 
-/* --- _PyUnicodeWriter API ----------------------------------------------- */ 
- 
-typedef struct { 
-    PyObject *buffer; 
-    void *data; 
-    enum PyUnicode_Kind kind; 
-    Py_UCS4 maxchar; 
-    Py_ssize_t size; 
-    Py_ssize_t pos; 
- 
-    /* minimum number of allocated characters (default: 0) */ 
-    Py_ssize_t min_length; 
- 
-    /* minimum character (default: 127, ASCII) */ 
-    Py_UCS4 min_char; 
- 
-    /* If non-zero, overallocate the buffer (default: 0). */ 
-    unsigned char overallocate; 
- 
-    /* If readonly is 1, buffer is a shared string (cannot be modified) 
-       and size is set to 0. */ 
-    unsigned char readonly; 
-} _PyUnicodeWriter ; 
- 
-/* Initialize a Unicode writer. 
- * 
- * By default, the minimum buffer size is 0 character and overallocation is 
- * disabled. Set min_length, min_char and overallocate attributes to control 
- * the allocation of the buffer. */ 
-PyAPI_FUNC(void) 
-_PyUnicodeWriter_Init(_PyUnicodeWriter *writer); 
- 
-/* Prepare the buffer to write 'length' characters 
-   with the specified maximum character. 
- 
-   Return 0 on success, raise an exception and return -1 on error. */ 
-#define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR)             \ 
-    (((MAXCHAR) <= (WRITER)->maxchar                                  \ 
-      && (LENGTH) <= (WRITER)->size - (WRITER)->pos)                  \ 
-     ? 0                                                              \ 
-     : (((LENGTH) == 0)                                               \ 
-        ? 0                                                           \ 
-        : _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR)))) 
- 
-/* Don't call this function directly, use the _PyUnicodeWriter_Prepare() macro 
-   instead. */ 
-PyAPI_FUNC(int) 
-_PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer, 
-                                 Py_ssize_t length, Py_UCS4 maxchar); 
- 
-/* Prepare the buffer to have at least the kind KIND. 
-   For example, kind=PyUnicode_2BYTE_KIND ensures that the writer will 
-   support characters in range U+000-U+FFFF. 
- 
-   Return 0 on success, raise an exception and return -1 on error. */ 
-#define _PyUnicodeWriter_PrepareKind(WRITER, KIND)                    \ 
-    (assert((KIND) != PyUnicode_WCHAR_KIND),                          \ 
-     (KIND) <= (WRITER)->kind                                         \ 
-     ? 0                                                              \ 
-     : _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND))) 
- 
-/* Don't call this function directly, use the _PyUnicodeWriter_PrepareKind() 
-   macro instead. */ 
-PyAPI_FUNC(int) 
-_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer, 
-                                     enum PyUnicode_Kind kind); 
- 
-/* Append a Unicode character. 
-   Return 0 on success, raise an exception and return -1 on error. */ 
-PyAPI_FUNC(int) 
-_PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer, 
-    Py_UCS4 ch 
-    ); 
- 
-/* Append a Unicode string. 
-   Return 0 on success, raise an exception and return -1 on error. */ 
-PyAPI_FUNC(int) 
-_PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer, 
-    PyObject *str               /* Unicode string */ 
-    ); 
- 
-/* Append a substring of a Unicode string. 
-   Return 0 on success, raise an exception and return -1 on error. */ 
-PyAPI_FUNC(int) 
-_PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer, 
-    PyObject *str,              /* Unicode string */ 
-    Py_ssize_t start, 
-    Py_ssize_t end 
-    ); 
- 
-/* Append an ASCII-encoded byte string. 
-   Return 0 on success, raise an exception and return -1 on error. */ 
-PyAPI_FUNC(int) 
-_PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer, 
-    const char *str,           /* ASCII-encoded byte string */ 
-    Py_ssize_t len             /* number of bytes, or -1 if unknown */ 
-    ); 
- 
-/* Append a latin1-encoded byte string. 
-   Return 0 on success, raise an exception and return -1 on error. */ 
-PyAPI_FUNC(int) 
-_PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer, 
-    const char *str,           /* latin1-encoded byte string */ 
-    Py_ssize_t len             /* length in bytes */ 
-    ); 
- 
-/* Get the value of the writer as a Unicode string. Clear the 
-   buffer of the writer. Raise an exception and return NULL 
-   on error. */ 
-PyAPI_FUNC(PyObject *) 
-_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer); 
- 
-/* Deallocate memory of a writer (clear its internal buffer). */ 
-PyAPI_FUNC(void) 
-_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer); 
- 
- 
-/* Format the object based on the format_spec, as defined in PEP 3101 
-   (Advanced String Formatting). */ 
-PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter( 
-    _PyUnicodeWriter *writer, 
-    PyObject *obj, 
-    PyObject *format_spec, 
-    Py_ssize_t start, 
-    Py_ssize_t end); 
- 
-/* --- Manage the default encoding ---------------------------------------- */ 
- 
-/* Returns a pointer to the default encoding (UTF-8) of the 
-   Unicode object unicode and the size of the encoded representation 
-   in bytes stored in *size. 
- 
-   In case of an error, no *size is set. 
- 
-   This function caches the UTF-8 encoded string in the unicodeobject 
-   and subsequent calls will return the same string.  The memory is released 
-   when the unicodeobject is deallocated. 
- 
-   _PyUnicode_AsStringAndSize is a #define for PyUnicode_AsUTF8AndSize to 
-   support the previous internal function with the same behaviour. 
-*/ 
- 
-PyAPI_FUNC(const char *) PyUnicode_AsUTF8AndSize( 
-    PyObject *unicode, 
-    Py_ssize_t *size); 
- 
-#define _PyUnicode_AsStringAndSize PyUnicode_AsUTF8AndSize 
- 
-/* Returns a pointer to the default encoding (UTF-8) of the 
-   Unicode object unicode. 
- 
-   Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation 
-   in the unicodeobject. 
- 
-   _PyUnicode_AsString is a #define for PyUnicode_AsUTF8 to 
-   support the previous internal function with the same behaviour. 
- 
-   Use of this API is DEPRECATED since no size information can be 
-   extracted from the returned data. 
-*/ 
- 
-PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode); 
- 
-#define _PyUnicode_AsString PyUnicode_AsUTF8 
- 
-/* --- Generic Codecs ----------------------------------------------------- */ 
- 
-/* Encodes a Py_UNICODE buffer of the given size and returns a 
-   Python string object. */ 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_Encode( 
-    const Py_UNICODE *s,        /* Unicode char buffer */ 
-    Py_ssize_t size,            /* number of Py_UNICODE chars to encode */ 
-    const char *encoding,       /* encoding */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-/* --- UTF-7 Codecs ------------------------------------------------------- */ 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */ 
-    int base64SetO,             /* Encode RFC2152 Set O characters in base64 */ 
-    int base64WhiteSpace,       /* Encode whitespace (sp, ht, nl, cr) in base64 */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7( 
-    PyObject *unicode,          /* Unicode object */ 
-    int base64SetO,             /* Encode RFC2152 Set O characters in base64 */ 
-    int base64WhiteSpace,       /* Encode whitespace (sp, ht, nl, cr) in base64 */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-/* --- UTF-8 Codecs ------------------------------------------------------- */ 
- 
-PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String( 
-    PyObject *unicode, 
-    const char *errors); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-/* --- UTF-32 Codecs ------------------------------------------------------ */ 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */ 
-    const char *errors,         /* error handling */ 
-    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */ 
-    ); 
- 
-PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32( 
-    PyObject *object,           /* Unicode object */ 
-    const char *errors,         /* error handling */ 
-    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */ 
-    ); 
- 
-/* --- UTF-16 Codecs ------------------------------------------------------ */ 
- 
-/* Returns a Python string object holding the UTF-16 encoded value of 
-   the Unicode data. 
- 
-   If byteorder is not 0, output is written according to the following 
-   byte order: 
- 
-   byteorder == -1: little endian 
-   byteorder == 0:  native byte order (writes a BOM mark) 
-   byteorder == 1:  big endian 
- 
-   If byteorder is 0, the output string will always start with the 
-   Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is 
-   prepended. 
- 
-   Note that Py_UNICODE data is being interpreted as UTF-16 reduced to 
-   UCS-2. This trick makes it possible to add full UTF-16 capabilities 
-   at a later point without compromising the APIs. 
- 
-*/ 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */ 
-    const char *errors,         /* error handling */ 
-    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */ 
-    ); 
- 
-PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16( 
-    PyObject* unicode,          /* Unicode object */ 
-    const char *errors,         /* error handling */ 
-    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */ 
-    ); 
- 
-/* --- Unicode-Escape Codecs ---------------------------------------------- */ 
- 
-/* Variant of PyUnicode_DecodeUnicodeEscape that supports partial decoding. */ 
-PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeStateful( 
-        const char *string,     /* Unicode-Escape encoded string */ 
-        Py_ssize_t length,      /* size of string */ 
-        const char *errors,     /* error handling */ 
-        Py_ssize_t *consumed    /* bytes consumed */ 
-); 
-/* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape 
-   chars. */ 
-PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal( 
-        const char *string,     /* Unicode-Escape encoded string */ 
-        Py_ssize_t length,      /* size of string */ 
-        const char *errors,     /* error handling */ 
-        Py_ssize_t *consumed,   /* bytes consumed */ 
-        const char **first_invalid_escape  /* on return, points to first 
-                                              invalid escaped char in 
-                                              string. */ 
-); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length           /* Number of Py_UNICODE chars to encode */ 
-    ); 
- 
-/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */ 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length           /* Number of Py_UNICODE chars to encode */ 
-    ); 
- 
-/* Variant of PyUnicode_DecodeRawUnicodeEscape that supports partial decoding. */ 
-PyAPI_FUNC(PyObject*) _PyUnicode_DecodeRawUnicodeEscapeStateful( 
-        const char *string,     /* Unicode-Escape encoded string */ 
-        Py_ssize_t length,      /* size of string */ 
-        const char *errors,     /* error handling */ 
-        Py_ssize_t *consumed    /* bytes consumed */ 
-); 
- 
-/* --- Latin-1 Codecs ----------------------------------------------------- */ 
- 
-PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String( 
-    PyObject* unicode, 
-    const char* errors); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-/* --- ASCII Codecs ------------------------------------------------------- */ 
- 
-PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString( 
-    PyObject* unicode, 
-    const char* errors); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-/* --- Character Map Codecs ----------------------------------------------- */ 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */ 
-    PyObject *mapping,          /* encoding mapping */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap( 
-    PyObject *unicode,          /* Unicode object */ 
-    PyObject *mapping,          /* encoding mapping */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-/* Translate a Py_UNICODE buffer of the given length by applying a 
-   character mapping table to it and return the resulting Unicode 
-   object. 
- 
-   The mapping table must map Unicode ordinal integers to Unicode strings, 
-   Unicode ordinal integers or None (causing deletion of the character). 
- 
-   Mapping tables may be dictionaries or sequences. Unmapped character 
-   ordinals (ones which cause a LookupError) are left untouched and 
-   are copied as-is. 
- 
-*/ 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */ 
-    PyObject *table,            /* Translate table */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-/* --- MBCS codecs for Windows -------------------------------------------- */ 
- 
-#ifdef MS_WINDOWS 
-Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS( 
-    const Py_UNICODE *data,     /* Unicode char buffer */ 
-    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */ 
-    const char *errors          /* error handling */ 
-    ); 
-#endif 
- 
-/* --- Decimal Encoder ---------------------------------------------------- */ 
- 
-/* Takes a Unicode string holding a decimal value and writes it into 
-   an output buffer using standard ASCII digit codes. 
- 
-   The output buffer has to provide at least length+1 bytes of storage 
-   area. The output string is 0-terminated. 
- 
-   The encoder converts whitespace to ' ', decimal characters to their 
-   corresponding ASCII digit and all other Latin-1 characters except 
-   \0 as-is. Characters outside this range (Unicode ordinals 1-256) 
-   are treated as errors. This includes embedded NULL bytes. 
- 
-   Error handling is defined by the errors argument: 
- 
-      NULL or "strict": raise a ValueError 
-      "ignore": ignore the wrong characters (these are not copied to the 
-                output buffer) 
-      "replace": replaces illegal characters with '?' 
- 
-   Returns 0 on success, -1 on failure. 
- 
-*/ 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(int) PyUnicode_EncodeDecimal( 
-    Py_UNICODE *s,              /* Unicode buffer */ 
-    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */ 
-    char *output,               /* Output buffer; must have size >= length */ 
-    const char *errors          /* error handling */ 
-    ); 
- 
-/* Transforms code points that have decimal digit property to the 
-   corresponding ASCII digit code points. 
- 
-   Returns a new Unicode string on success, NULL on failure. 
-*/ 
- 
-Py_DEPRECATED(3.3) 
-PyAPI_FUNC(PyObject*) PyUnicode_TransformDecimalToASCII( 
-    Py_UNICODE *s,              /* Unicode buffer */ 
-    Py_ssize_t length           /* Number of Py_UNICODE chars to transform */ 
-    ); 
- 
-/* Coverts a Unicode object holding a decimal value to an ASCII string 
-   for using in int, float and complex parsers. 
-   Transforms code points that have decimal digit property to the 
-   corresponding ASCII digit code points.  Transforms spaces to ASCII. 
-   Transforms code points starting from the first non-ASCII code point that 
-   is neither a decimal digit nor a space to the end into '?'. */ 
- 
-PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII( 
-    PyObject *unicode           /* Unicode object */ 
-    ); 
- 
-/* --- Methods & Slots ---------------------------------------------------- */ 
- 
-PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray( 
-    PyObject *separator, 
-    PyObject *const *items, 
-    Py_ssize_t seqlen 
-    ); 
- 
-/* Test whether a unicode is equal to ASCII identifier.  Return 1 if true, 
-   0 otherwise.  The right argument must be ASCII identifier. 
-   Any error occurs inside will be cleared before return. */ 
-PyAPI_FUNC(int) _PyUnicode_EqualToASCIIId( 
-    PyObject *left,             /* Left string */ 
-    _Py_Identifier *right       /* Right identifier */ 
-    ); 
- 
-/* Test whether a unicode is equal to ASCII string.  Return 1 if true, 
-   0 otherwise.  The right argument must be ASCII-encoded string. 
-   Any error occurs inside will be cleared before return. */ 
-PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString( 
-    PyObject *left, 
-    const char *right           /* ASCII-encoded string */ 
-    ); 
- 
-/* Externally visible for str.strip(unicode) */ 
-PyAPI_FUNC(PyObject *) _PyUnicode_XStrip( 
-    PyObject *self, 
-    int striptype, 
-    PyObject *sepobj 
-    ); 
- 
-/* Using explicit passed-in values, insert the thousands grouping 
-   into the string pointed to by buffer.  For the argument descriptions, 
-   see Objects/stringlib/localeutil.h */ 
-PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping( 
-    _PyUnicodeWriter *writer, 
-    Py_ssize_t n_buffer, 
-    PyObject *digits, 
-    Py_ssize_t d_pos, 
-    Py_ssize_t n_digits, 
-    Py_ssize_t min_width, 
-    const char *grouping, 
-    PyObject *thousands_sep, 
-    Py_UCS4 *maxchar); 
- 
-/* === Characters Type APIs =============================================== */ 
- 
-/* Helper array used by Py_UNICODE_ISSPACE(). */ 
- 
-PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[]; 
- 
-/* These should not be used directly. Use the Py_UNICODE_IS* and 
-   Py_UNICODE_TO* macros instead. 
- 
-   These APIs are implemented in Objects/unicodectype.c. 
- 
-*/ 
- 
-PyAPI_FUNC(int) _PyUnicode_IsLowercase( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsUppercase( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsTitlecase( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsXidStart( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsXidContinue( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsWhitespace( 
-    const Py_UCS4 ch         /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsLinebreak( 
-    const Py_UCS4 ch         /* Unicode character */ 
-    ); 
- 
-/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_ToLowerFull( 
-    Py_UCS4 ch,       /* Unicode character */ 
-    Py_UCS4 *res 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_ToTitleFull( 
-    Py_UCS4 ch,       /* Unicode character */ 
-    Py_UCS4 *res 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_ToUpperFull( 
-    Py_UCS4 ch,       /* Unicode character */ 
-    Py_UCS4 *res 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_ToFoldedFull( 
-    Py_UCS4 ch,       /* Unicode character */ 
-    Py_UCS4 *res 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsCaseIgnorable( 
-    Py_UCS4 ch         /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsCased( 
-    Py_UCS4 ch         /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_ToDigit( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(double) _PyUnicode_ToNumeric( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsDigit( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsNumeric( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsPrintable( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-PyAPI_FUNC(int) _PyUnicode_IsAlpha( 
-    Py_UCS4 ch       /* Unicode character */ 
-    ); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(size_t) Py_UNICODE_strlen( 
-    const Py_UNICODE *u 
-    ); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcpy( 
-    Py_UNICODE *s1, 
-    const Py_UNICODE *s2); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcat( 
-    Py_UNICODE *s1, const Py_UNICODE *s2); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strncpy( 
-    Py_UNICODE *s1, 
-    const Py_UNICODE *s2, 
-    size_t n); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(int) Py_UNICODE_strcmp( 
-    const Py_UNICODE *s1, 
-    const Py_UNICODE *s2 
-    ); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(int) Py_UNICODE_strncmp( 
-    const Py_UNICODE *s1, 
-    const Py_UNICODE *s2, 
-    size_t n 
-    ); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strchr( 
-    const Py_UNICODE *s, 
-    Py_UNICODE c 
-    ); 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strrchr( 
-    const Py_UNICODE *s, 
-    Py_UNICODE c 
-    ); 
- 
-PyAPI_FUNC(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int); 
- 
-/* Create a copy of a unicode string ending with a nul character. Return NULL 
-   and raise a MemoryError exception on memory allocation failure, otherwise 
-   return a new allocated buffer (use PyMem_Free() to free the buffer). */ 
- 
-Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) PyUnicode_AsUnicodeCopy( 
-    PyObject *unicode 
-    ); 
- 
-/* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/ 
-PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*); 
- 
-/* Fast equality check when the inputs are known to be exact unicode types 
-   and where the hash values are equal (i.e. a very probable match) */ 
-PyAPI_FUNC(int) _PyUnicode_EQ(PyObject *, PyObject *); 
- 
-PyAPI_FUNC(Py_ssize_t) _PyUnicode_ScanIdentifier(PyObject *); 
- 
-#ifdef __cplusplus 
-} 
-#endif 
+#ifndef Py_CPYTHON_UNICODEOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Py_UNICODE was the native Unicode storage format (code unit) used by
+   Python and represents a single Unicode element in the Unicode type.
+   With PEP 393, Py_UNICODE is deprecated and replaced with a
+   typedef to wchar_t. */
+#define PY_UNICODE_TYPE wchar_t
+/* Py_DEPRECATED(3.3) */ typedef wchar_t Py_UNICODE;
+
+/* --- Internal Unicode Operations ---------------------------------------- */
+
+/* Since splitting on whitespace is an important use case, and
+   whitespace in most situations is solely ASCII whitespace, we
+   optimize for the common case by using a quick look-up table
+   _Py_ascii_whitespace (see below) with an inlined check.
+
+ */
+#define Py_UNICODE_ISSPACE(ch) \
+    ((Py_UCS4)(ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch))
+
+#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch)
+#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch)
+#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch)
+#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch)
+
+#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch)
+#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch)
+#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch)
+
+#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch)
+#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch)
+#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch)
+#define Py_UNICODE_ISPRINTABLE(ch) _PyUnicode_IsPrintable(ch)
+
+#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch)
+#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch)
+#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch)
+
+#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch)
+
+#define Py_UNICODE_ISALNUM(ch) \
+       (Py_UNICODE_ISALPHA(ch) || \
+    Py_UNICODE_ISDECIMAL(ch) || \
+    Py_UNICODE_ISDIGIT(ch) || \
+    Py_UNICODE_ISNUMERIC(ch))
+
+Py_DEPRECATED(3.3) static inline void
+Py_UNICODE_COPY(Py_UNICODE *target, const Py_UNICODE *source, Py_ssize_t length) {
+    memcpy(target, source, (size_t)(length) * sizeof(Py_UNICODE));
+}
+
+Py_DEPRECATED(3.3) static inline void
+Py_UNICODE_FILL(Py_UNICODE *target, Py_UNICODE value, Py_ssize_t length) {
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        target[i] = value;
+    }
+}
+
+/* macros to work with surrogates */
+#define Py_UNICODE_IS_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDFFF)
+#define Py_UNICODE_IS_HIGH_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDBFF)
+#define Py_UNICODE_IS_LOW_SURROGATE(ch) (0xDC00 <= (ch) && (ch) <= 0xDFFF)
+/* Join two surrogate characters and return a single Py_UCS4 value. */
+#define Py_UNICODE_JOIN_SURROGATES(high, low)  \
+    (((((Py_UCS4)(high) & 0x03FF) << 10) |      \
+      ((Py_UCS4)(low) & 0x03FF)) + 0x10000)
+/* high surrogate = top 10 bits added to D800 */
+#define Py_UNICODE_HIGH_SURROGATE(ch) (0xD800 - (0x10000 >> 10) + ((ch) >> 10))
+/* low surrogate = bottom 10 bits added to DC00 */
+#define Py_UNICODE_LOW_SURROGATE(ch) (0xDC00 + ((ch) & 0x3FF))
+
+/* --- Unicode Type ------------------------------------------------------- */
+
+/* ASCII-only strings created through PyUnicode_New use the PyASCIIObject
+   structure. state.ascii and state.compact are set, and the data
+   immediately follow the structure. utf8_length and wstr_length can be found
+   in the length field; the utf8 pointer is equal to the data pointer. */
+typedef struct {
+    /* There are 4 forms of Unicode strings:
+
+       - compact ascii:
+
+         * structure = PyASCIIObject
+         * test: PyUnicode_IS_COMPACT_ASCII(op)
+         * kind = PyUnicode_1BYTE_KIND
+         * compact = 1
+         * ascii = 1
+         * ready = 1
+         * (length is the length of the utf8 and wstr strings)
+         * (data starts just after the structure)
+         * (since ASCII is decoded from UTF-8, the utf8 string are the data)
+
+       - compact:
+
+         * structure = PyCompactUnicodeObject
+         * test: PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op)
+         * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
+           PyUnicode_4BYTE_KIND
+         * compact = 1
+         * ready = 1
+         * ascii = 0
+         * utf8 is not shared with data
+         * utf8_length = 0 if utf8 is NULL
+         * wstr is shared with data and wstr_length=length
+           if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2
+           or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_t)=4
+         * wstr_length = 0 if wstr is NULL
+         * (data starts just after the structure)
+
+       - legacy string, not ready:
+
+         * structure = PyUnicodeObject
+         * test: kind == PyUnicode_WCHAR_KIND
+         * length = 0 (use wstr_length)
+         * hash = -1
+         * kind = PyUnicode_WCHAR_KIND
+         * compact = 0
+         * ascii = 0
+         * ready = 0
+         * interned = SSTATE_NOT_INTERNED
+         * wstr is not NULL
+         * data.any is NULL
+         * utf8 is NULL
+         * utf8_length = 0
+
+       - legacy string, ready:
+
+         * structure = PyUnicodeObject structure
+         * test: !PyUnicode_IS_COMPACT(op) && kind != PyUnicode_WCHAR_KIND
+         * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
+           PyUnicode_4BYTE_KIND
+         * compact = 0
+         * ready = 1
+         * data.any is not NULL
+         * utf8 is shared and utf8_length = length with data.any if ascii = 1
+         * utf8_length = 0 if utf8 is NULL
+         * wstr is shared with data.any and wstr_length = length
+           if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2
+           or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_4)=4
+         * wstr_length = 0 if wstr is NULL
+
+       Compact strings use only one memory block (structure + characters),
+       whereas legacy strings use one block for the structure and one block
+       for characters.
+
+       Legacy strings are created by PyUnicode_FromUnicode() and
+       PyUnicode_FromStringAndSize(NULL, size) functions. They become ready
+       when PyUnicode_READY() is called.
+
+       See also _PyUnicode_CheckConsistency().
+    */
+    PyObject_HEAD
+    Py_ssize_t length;          /* Number of code points in the string */
+    Py_hash_t hash;             /* Hash value; -1 if not set */
+    struct {
+        /*
+           SSTATE_NOT_INTERNED (0)
+           SSTATE_INTERNED_MORTAL (1)
+           SSTATE_INTERNED_IMMORTAL (2)
+
+           If interned != SSTATE_NOT_INTERNED, the two references from the
+           dictionary to this object are *not* counted in ob_refcnt.
+         */
+        unsigned int interned:2;
+        /* Character size:
+
+           - PyUnicode_WCHAR_KIND (0):
+
+             * character type = wchar_t (16 or 32 bits, depending on the
+               platform)
+
+           - PyUnicode_1BYTE_KIND (1):
+
+             * character type = Py_UCS1 (8 bits, unsigned)
+             * all characters are in the range U+0000-U+00FF (latin1)
+             * if ascii is set, all characters are in the range U+0000-U+007F
+               (ASCII), otherwise at least one character is in the range
+               U+0080-U+00FF
+
+           - PyUnicode_2BYTE_KIND (2):
+
+             * character type = Py_UCS2 (16 bits, unsigned)
+             * all characters are in the range U+0000-U+FFFF (BMP)
+             * at least one character is in the range U+0100-U+FFFF
+
+           - PyUnicode_4BYTE_KIND (4):
+
+             * character type = Py_UCS4 (32 bits, unsigned)
+             * all characters are in the range U+0000-U+10FFFF
+             * at least one character is in the range U+10000-U+10FFFF
+         */
+        unsigned int kind:3;
+        /* Compact is with respect to the allocation scheme. Compact unicode
+           objects only require one memory block while non-compact objects use
+           one block for the PyUnicodeObject struct and another for its data
+           buffer. */
+        unsigned int compact:1;
+        /* The string only contains characters in the range U+0000-U+007F (ASCII)
+           and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is
+           set, use the PyASCIIObject structure. */
+        unsigned int ascii:1;
+        /* The ready flag indicates whether the object layout is initialized
+           completely. This means that this is either a compact object, or
+           the data pointer is filled out. The bit is redundant, and helps
+           to minimize the test in PyUnicode_IS_READY(). */
+        unsigned int ready:1;
+        /* Padding to ensure that PyUnicode_DATA() is always aligned to
+           4 bytes (see issue #19537 on m68k). */
+        unsigned int :24;
+    } state;
+    wchar_t *wstr;              /* wchar_t representation (null-terminated) */
+} PyASCIIObject;
+
+/* Non-ASCII strings allocated through PyUnicode_New use the
+   PyCompactUnicodeObject structure. state.compact is set, and the data
+   immediately follow the structure. */
+typedef struct {
+    PyASCIIObject _base;
+    Py_ssize_t utf8_length;     /* Number of bytes in utf8, excluding the
+                                 * terminating \0. */
+    char *utf8;                 /* UTF-8 representation (null-terminated) */
+    Py_ssize_t wstr_length;     /* Number of code points in wstr, possible
+                                 * surrogates count as two code points. */
+} PyCompactUnicodeObject;
+
+/* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the
+   PyUnicodeObject structure. The actual string data is initially in the wstr
+   block, and copied into the data block using _PyUnicode_Ready. */
+typedef struct {
+    PyCompactUnicodeObject _base;
+    union {
+        void *any;
+        Py_UCS1 *latin1;
+        Py_UCS2 *ucs2;
+        Py_UCS4 *ucs4;
+    } data;                     /* Canonical, smallest-form Unicode buffer */
+} PyUnicodeObject;
+
+PyAPI_FUNC(int) _PyUnicode_CheckConsistency(
+    PyObject *op,
+    int check_content);
+
+/* Fast access macros */
+
+/* Returns the deprecated Py_UNICODE representation's size in code units
+   (this includes surrogate pairs as 2 units).
+   If the Py_UNICODE representation is not available, it will be computed
+   on request.  Use PyUnicode_GET_LENGTH() for the length in code points. */
+
+/* Py_DEPRECATED(3.3) */
+#define PyUnicode_GET_SIZE(op)                       \
+    (assert(PyUnicode_Check(op)),                    \
+     (((PyASCIIObject *)(op))->wstr) ?               \
+      PyUnicode_WSTR_LENGTH(op) :                    \
+      ((void)PyUnicode_AsUnicode(_PyObject_CAST(op)),\
+       assert(((PyASCIIObject *)(op))->wstr),        \
+       PyUnicode_WSTR_LENGTH(op)))
+
+/* Py_DEPRECATED(3.3) */
+#define PyUnicode_GET_DATA_SIZE(op) \
+    (PyUnicode_GET_SIZE(op) * Py_UNICODE_SIZE)
+
+/* Alias for PyUnicode_AsUnicode().  This will create a wchar_t/Py_UNICODE
+   representation on demand.  Using this macro is very inefficient now,
+   try to port your code to use the new PyUnicode_*BYTE_DATA() macros or
+   use PyUnicode_WRITE() and PyUnicode_READ(). */
+
+/* Py_DEPRECATED(3.3) */
+#define PyUnicode_AS_UNICODE(op) \
+    (assert(PyUnicode_Check(op)), \
+     (((PyASCIIObject *)(op))->wstr) ? (((PyASCIIObject *)(op))->wstr) : \
+      PyUnicode_AsUnicode(_PyObject_CAST(op)))
+
+/* Py_DEPRECATED(3.3) */
+#define PyUnicode_AS_DATA(op) \
+    ((const char *)(PyUnicode_AS_UNICODE(op)))
+
+
+/* --- Flexible String Representation Helper Macros (PEP 393) -------------- */
+
+/* Values for PyASCIIObject.state: */
+
+/* Interning state. */
+#define SSTATE_NOT_INTERNED 0
+#define SSTATE_INTERNED_MORTAL 1
+#define SSTATE_INTERNED_IMMORTAL 2
+
+/* Return true if the string contains only ASCII characters, or 0 if not. The
+   string may be compact (PyUnicode_IS_COMPACT_ASCII) or not, but must be
+   ready. */
+#define PyUnicode_IS_ASCII(op)                   \
+    (assert(PyUnicode_Check(op)),                \
+     assert(PyUnicode_IS_READY(op)),             \
+     ((PyASCIIObject*)op)->state.ascii)
+
+/* Return true if the string is compact or 0 if not.
+   No type checks or Ready calls are performed. */
+#define PyUnicode_IS_COMPACT(op) \
+    (((PyASCIIObject*)(op))->state.compact)
+
+/* Return true if the string is a compact ASCII string (use PyASCIIObject
+   structure), or 0 if not.  No type checks or Ready calls are performed. */
+#define PyUnicode_IS_COMPACT_ASCII(op)                 \
+    (((PyASCIIObject*)op)->state.ascii && PyUnicode_IS_COMPACT(op))
+
+enum PyUnicode_Kind {
+/* String contains only wstr byte characters.  This is only possible
+   when the string was created with a legacy API and _PyUnicode_Ready()
+   has not been called yet.  */
+    PyUnicode_WCHAR_KIND = 0,
+/* Return values of the PyUnicode_KIND() macro: */
+    PyUnicode_1BYTE_KIND = 1,
+    PyUnicode_2BYTE_KIND = 2,
+    PyUnicode_4BYTE_KIND = 4
+};
+
+/* Return pointers to the canonical representation cast to unsigned char,
+   Py_UCS2, or Py_UCS4 for direct character access.
+   No checks are performed, use PyUnicode_KIND() before to ensure
+   these will work correctly. */
+
+#define PyUnicode_1BYTE_DATA(op) ((Py_UCS1*)PyUnicode_DATA(op))
+#define PyUnicode_2BYTE_DATA(op) ((Py_UCS2*)PyUnicode_DATA(op))
+#define PyUnicode_4BYTE_DATA(op) ((Py_UCS4*)PyUnicode_DATA(op))
+
+/* Return one of the PyUnicode_*_KIND values defined above. */
+#define PyUnicode_KIND(op) \
+    (assert(PyUnicode_Check(op)), \
+     assert(PyUnicode_IS_READY(op)),            \
+     ((PyASCIIObject *)(op))->state.kind)
+
+/* Return a void pointer to the raw unicode buffer. */
+#define _PyUnicode_COMPACT_DATA(op)                     \
+    (PyUnicode_IS_ASCII(op) ?                   \
+     ((void*)((PyASCIIObject*)(op) + 1)) :              \
+     ((void*)((PyCompactUnicodeObject*)(op) + 1)))
+
+#define _PyUnicode_NONCOMPACT_DATA(op)                  \
+    (assert(((PyUnicodeObject*)(op))->data.any),        \
+     ((((PyUnicodeObject *)(op))->data.any)))
+
+#define PyUnicode_DATA(op) \
+    (assert(PyUnicode_Check(op)), \
+     PyUnicode_IS_COMPACT(op) ? _PyUnicode_COMPACT_DATA(op) :   \
+     _PyUnicode_NONCOMPACT_DATA(op))
+
+/* In the access macros below, "kind" may be evaluated more than once.
+   All other macro parameters are evaluated exactly once, so it is safe
+   to put side effects into them (such as increasing the index). */
+
+/* Write into the canonical representation, this macro does not do any sanity
+   checks and is intended for usage in loops.  The caller should cache the
+   kind and data pointers obtained from other macro calls.
+   index is the index in the string (starts at 0) and value is the new
+   code point value which should be written to that location. */
+#define PyUnicode_WRITE(kind, data, index, value) \
+    do { \
+        switch ((kind)) { \
+        case PyUnicode_1BYTE_KIND: { \
+            ((Py_UCS1 *)(data))[(index)] = (Py_UCS1)(value); \
+            break; \
+        } \
+        case PyUnicode_2BYTE_KIND: { \
+            ((Py_UCS2 *)(data))[(index)] = (Py_UCS2)(value); \
+            break; \
+        } \
+        default: { \
+            assert((kind) == PyUnicode_4BYTE_KIND); \
+            ((Py_UCS4 *)(data))[(index)] = (Py_UCS4)(value); \
+        } \
+        } \
+    } while (0)
+
+/* Read a code point from the string's canonical representation.  No checks
+   or ready calls are performed. */
+#define PyUnicode_READ(kind, data, index) \
+    ((Py_UCS4) \
+    ((kind) == PyUnicode_1BYTE_KIND ? \
+        ((const Py_UCS1 *)(data))[(index)] : \
+        ((kind) == PyUnicode_2BYTE_KIND ? \
+            ((const Py_UCS2 *)(data))[(index)] : \
+            ((const Py_UCS4 *)(data))[(index)] \
+        ) \
+    ))
+
+/* PyUnicode_READ_CHAR() is less efficient than PyUnicode_READ() because it
+   calls PyUnicode_KIND() and might call it twice.  For single reads, use
+   PyUnicode_READ_CHAR, for multiple consecutive reads callers should
+   cache kind and use PyUnicode_READ instead. */
+#define PyUnicode_READ_CHAR(unicode, index) \
+    (assert(PyUnicode_Check(unicode)),          \
+     assert(PyUnicode_IS_READY(unicode)),       \
+     (Py_UCS4)                                  \
+        (PyUnicode_KIND((unicode)) == PyUnicode_1BYTE_KIND ? \
+            ((const Py_UCS1 *)(PyUnicode_DATA((unicode))))[(index)] : \
+            (PyUnicode_KIND((unicode)) == PyUnicode_2BYTE_KIND ? \
+                ((const Py_UCS2 *)(PyUnicode_DATA((unicode))))[(index)] : \
+                ((const Py_UCS4 *)(PyUnicode_DATA((unicode))))[(index)] \
+            ) \
+        ))
+
+/* Returns the length of the unicode string. The caller has to make sure that
+   the string has it's canonical representation set before calling
+   this macro.  Call PyUnicode_(FAST_)Ready to ensure that. */
+#define PyUnicode_GET_LENGTH(op)                \
+    (assert(PyUnicode_Check(op)),               \
+     assert(PyUnicode_IS_READY(op)),            \
+     ((PyASCIIObject *)(op))->length)
+
+
+/* Fast check to determine whether an object is ready. Equivalent to
+   PyUnicode_IS_COMPACT(op) || ((PyUnicodeObject*)(op))->data.any */
+
+#define PyUnicode_IS_READY(op) (((PyASCIIObject*)op)->state.ready)
+
+/* PyUnicode_READY() does less work than _PyUnicode_Ready() in the best
+   case.  If the canonical representation is not yet set, it will still call
+   _PyUnicode_Ready().
+   Returns 0 on success and -1 on errors. */
+#define PyUnicode_READY(op)                        \
+    (assert(PyUnicode_Check(op)),                       \
+     (PyUnicode_IS_READY(op) ?                          \
+      0 : _PyUnicode_Ready(_PyObject_CAST(op))))
+
+/* Return a maximum character value which is suitable for creating another
+   string based on op.  This is always an approximation but more efficient
+   than iterating over the string. */
+#define PyUnicode_MAX_CHAR_VALUE(op) \
+    (assert(PyUnicode_IS_READY(op)),                                    \
+     (PyUnicode_IS_ASCII(op) ?                                          \
+      (0x7f) :                                                          \
+      (PyUnicode_KIND(op) == PyUnicode_1BYTE_KIND ?                     \
+       (0xffU) :                                                        \
+       (PyUnicode_KIND(op) == PyUnicode_2BYTE_KIND ?                    \
+        (0xffffU) :                                                     \
+        (0x10ffffU)))))
+
+Py_DEPRECATED(3.3)
+static inline Py_ssize_t _PyUnicode_get_wstr_length(PyObject *op) {
+    return PyUnicode_IS_COMPACT_ASCII(op) ?
+            ((PyASCIIObject*)op)->length :
+            ((PyCompactUnicodeObject*)op)->wstr_length;
+}
+#define PyUnicode_WSTR_LENGTH(op) _PyUnicode_get_wstr_length((PyObject*)op)
+
+/* === Public API ========================================================= */
+
+/* --- Plain Py_UNICODE --------------------------------------------------- */
+
+/* With PEP 393, this is the recommended way to allocate a new unicode object.
+   This function will allocate the object and its buffer in a single memory
+   block.  Objects created using this function are not resizable. */
+PyAPI_FUNC(PyObject*) PyUnicode_New(
+    Py_ssize_t size,            /* Number of code points in the new string */
+    Py_UCS4 maxchar             /* maximum code point value in the string */
+    );
+
+/* Initializes the canonical string representation from the deprecated
+   wstr/Py_UNICODE representation. This function is used to convert Unicode
+   objects which were created using the old API to the new flexible format
+   introduced with PEP 393.
+
+   Don't call this function directly, use the public PyUnicode_READY() macro
+   instead. */
+PyAPI_FUNC(int) _PyUnicode_Ready(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* Get a copy of a Unicode string. */
+PyAPI_FUNC(PyObject*) _PyUnicode_Copy(
+    PyObject *unicode
+    );
+
+/* Copy character from one unicode object into another, this function performs
+   character conversion when necessary and falls back to memcpy() if possible.
+
+   Fail if to is too small (smaller than *how_many* or smaller than
+   len(from)-from_start), or if kind(from[from_start:from_start+how_many]) >
+   kind(to), or if *to* has more than 1 reference.
+
+   Return the number of written character, or return -1 and raise an exception
+   on error.
+
+   Pseudo-code:
+
+       how_many = min(how_many, len(from) - from_start)
+       to[to_start:to_start+how_many] = from[from_start:from_start+how_many]
+       return how_many
+
+   Note: The function doesn't write a terminating null character.
+   */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters(
+    PyObject *to,
+    Py_ssize_t to_start,
+    PyObject *from,
+    Py_ssize_t from_start,
+    Py_ssize_t how_many
+    );
+
+/* Unsafe version of PyUnicode_CopyCharacters(): don't check arguments and so
+   may crash if parameters are invalid (e.g. if the output string
+   is too short). */
+PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters(
+    PyObject *to,
+    Py_ssize_t to_start,
+    PyObject *from,
+    Py_ssize_t from_start,
+    Py_ssize_t how_many
+    );
+
+/* Fill a string with a character: write fill_char into
+   unicode[start:start+length].
+
+   Fail if fill_char is bigger than the string maximum character, or if the
+   string has more than 1 reference.
+
+   Return the number of written character, or return -1 and raise an exception
+   on error. */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill(
+    PyObject *unicode,
+    Py_ssize_t start,
+    Py_ssize_t length,
+    Py_UCS4 fill_char
+    );
+
+/* Unsafe version of PyUnicode_Fill(): don't check arguments and so may crash
+   if parameters are invalid (e.g. if length is longer than the string). */
+PyAPI_FUNC(void) _PyUnicode_FastFill(
+    PyObject *unicode,
+    Py_ssize_t start,
+    Py_ssize_t length,
+    Py_UCS4 fill_char
+    );
+
+/* Create a Unicode Object from the Py_UNICODE buffer u of the given
+   size.
+
+   u may be NULL which causes the contents to be undefined. It is the
+   user's responsibility to fill in the needed data afterwards. Note
+   that modifying the Unicode object contents after construction is
+   only allowed if u was set to NULL.
+
+   The buffer is copied into the new object. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode(
+    const Py_UNICODE *u,        /* Unicode buffer */
+    Py_ssize_t size             /* size of buffer */
+    );
+
+/* Create a new string from a buffer of Py_UCS1, Py_UCS2 or Py_UCS4 characters.
+   Scan the string to find the maximum character. */
+PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData(
+    int kind,
+    const void *buffer,
+    Py_ssize_t size);
+
+/* Create a new string from a buffer of ASCII characters.
+   WARNING: Don't check if the string contains any non-ASCII character. */
+PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII(
+    const char *buffer,
+    Py_ssize_t size);
+
+/* Compute the maximum character of the substring unicode[start:end].
+   Return 127 for an empty string. */
+PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar (
+    PyObject *unicode,
+    Py_ssize_t start,
+    Py_ssize_t end);
+
+/* Return a read-only pointer to the Unicode object's internal
+   Py_UNICODE buffer.
+   If the wchar_t/Py_UNICODE representation is not yet available, this
+   function will calculate it. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* Similar to PyUnicode_AsUnicode(), but raises a ValueError if the string
+   contains null characters. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(const Py_UNICODE *) _PyUnicode_AsUnicode(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* Return a read-only pointer to the Unicode object's internal
+   Py_UNICODE buffer and save the length at size.
+   If the wchar_t/Py_UNICODE representation is not yet available, this
+   function will calculate it. */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize(
+    PyObject *unicode,          /* Unicode object */
+    Py_ssize_t *size            /* location where to save the length */
+    );
+
+/* Get the maximum ordinal for a Unicode character. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void);
+
+
+/* --- _PyUnicodeWriter API ----------------------------------------------- */
+
+typedef struct {
+    PyObject *buffer;
+    void *data;
+    enum PyUnicode_Kind kind;
+    Py_UCS4 maxchar;
+    Py_ssize_t size;
+    Py_ssize_t pos;
+
+    /* minimum number of allocated characters (default: 0) */
+    Py_ssize_t min_length;
+
+    /* minimum character (default: 127, ASCII) */
+    Py_UCS4 min_char;
+
+    /* If non-zero, overallocate the buffer (default: 0). */
+    unsigned char overallocate;
+
+    /* If readonly is 1, buffer is a shared string (cannot be modified)
+       and size is set to 0. */
+    unsigned char readonly;
+} _PyUnicodeWriter ;
+
+/* Initialize a Unicode writer.
+ *
+ * By default, the minimum buffer size is 0 character and overallocation is
+ * disabled. Set min_length, min_char and overallocate attributes to control
+ * the allocation of the buffer. */
+PyAPI_FUNC(void)
+_PyUnicodeWriter_Init(_PyUnicodeWriter *writer);
+
+/* Prepare the buffer to write 'length' characters
+   with the specified maximum character.
+
+   Return 0 on success, raise an exception and return -1 on error. */
+#define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR)             \
+    (((MAXCHAR) <= (WRITER)->maxchar                                  \
+      && (LENGTH) <= (WRITER)->size - (WRITER)->pos)                  \
+     ? 0                                                              \
+     : (((LENGTH) == 0)                                               \
+        ? 0                                                           \
+        : _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR))))
+
+/* Don't call this function directly, use the _PyUnicodeWriter_Prepare() macro
+   instead. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer,
+                                 Py_ssize_t length, Py_UCS4 maxchar);
+
+/* Prepare the buffer to have at least the kind KIND.
+   For example, kind=PyUnicode_2BYTE_KIND ensures that the writer will
+   support characters in range U+000-U+FFFF.
+
+   Return 0 on success, raise an exception and return -1 on error. */
+#define _PyUnicodeWriter_PrepareKind(WRITER, KIND)                    \
+    (assert((KIND) != PyUnicode_WCHAR_KIND),                          \
+     (KIND) <= (WRITER)->kind                                         \
+     ? 0                                                              \
+     : _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND)))
+
+/* Don't call this function directly, use the _PyUnicodeWriter_PrepareKind()
+   macro instead. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer,
+                                     enum PyUnicode_Kind kind);
+
+/* Append a Unicode character.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer,
+    Py_UCS4 ch
+    );
+
+/* Append a Unicode string.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer,
+    PyObject *str               /* Unicode string */
+    );
+
+/* Append a substring of a Unicode string.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer,
+    PyObject *str,              /* Unicode string */
+    Py_ssize_t start,
+    Py_ssize_t end
+    );
+
+/* Append an ASCII-encoded byte string.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer,
+    const char *str,           /* ASCII-encoded byte string */
+    Py_ssize_t len             /* number of bytes, or -1 if unknown */
+    );
+
+/* Append a latin1-encoded byte string.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer,
+    const char *str,           /* latin1-encoded byte string */
+    Py_ssize_t len             /* length in bytes */
+    );
+
+/* Get the value of the writer as a Unicode string. Clear the
+   buffer of the writer. Raise an exception and return NULL
+   on error. */
+PyAPI_FUNC(PyObject *)
+_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer);
+
+/* Deallocate memory of a writer (clear its internal buffer). */
+PyAPI_FUNC(void)
+_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer);
+
+
+/* Format the object based on the format_spec, as defined in PEP 3101
+   (Advanced String Formatting). */
+PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter(
+    _PyUnicodeWriter *writer,
+    PyObject *obj,
+    PyObject *format_spec,
+    Py_ssize_t start,
+    Py_ssize_t end);
+
+/* --- Manage the default encoding ---------------------------------------- */
+
+/* Returns a pointer to the default encoding (UTF-8) of the
+   Unicode object unicode and the size of the encoded representation
+   in bytes stored in *size.
+
+   In case of an error, no *size is set.
+
+   This function caches the UTF-8 encoded string in the unicodeobject
+   and subsequent calls will return the same string.  The memory is released
+   when the unicodeobject is deallocated.
+
+   _PyUnicode_AsStringAndSize is a #define for PyUnicode_AsUTF8AndSize to
+   support the previous internal function with the same behaviour.
+*/
+
+PyAPI_FUNC(const char *) PyUnicode_AsUTF8AndSize(
+    PyObject *unicode,
+    Py_ssize_t *size);
+
+#define _PyUnicode_AsStringAndSize PyUnicode_AsUTF8AndSize
+
+/* Returns a pointer to the default encoding (UTF-8) of the
+   Unicode object unicode.
+
+   Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation
+   in the unicodeobject.
+
+   _PyUnicode_AsString is a #define for PyUnicode_AsUTF8 to
+   support the previous internal function with the same behaviour.
+
+   Use of this API is DEPRECATED since no size information can be
+   extracted from the returned data.
+*/
+
+PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode);
+
+#define _PyUnicode_AsString PyUnicode_AsUTF8
+
+/* --- Generic Codecs ----------------------------------------------------- */
+
+/* Encodes a Py_UNICODE buffer of the given size and returns a
+   Python string object. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_Encode(
+    const Py_UNICODE *s,        /* Unicode char buffer */
+    Py_ssize_t size,            /* number of Py_UNICODE chars to encode */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
+    );
+
+/* --- UTF-7 Codecs ------------------------------------------------------- */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    int base64SetO,             /* Encode RFC2152 Set O characters in base64 */
+    int base64WhiteSpace,       /* Encode whitespace (sp, ht, nl, cr) in base64 */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7(
+    PyObject *unicode,          /* Unicode object */
+    int base64SetO,             /* Encode RFC2152 Set O characters in base64 */
+    int base64WhiteSpace,       /* Encode whitespace (sp, ht, nl, cr) in base64 */
+    const char *errors          /* error handling */
+    );
+
+/* --- UTF-8 Codecs ------------------------------------------------------- */
+
+PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String(
+    PyObject *unicode,
+    const char *errors);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+
+/* --- UTF-32 Codecs ------------------------------------------------------ */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32(
+    PyObject *object,           /* Unicode object */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    );
+
+/* --- UTF-16 Codecs ------------------------------------------------------ */
+
+/* Returns a Python string object holding the UTF-16 encoded value of
+   the Unicode data.
+
+   If byteorder is not 0, output is written according to the following
+   byte order:
+
+   byteorder == -1: little endian
+   byteorder == 0:  native byte order (writes a BOM mark)
+   byteorder == 1:  big endian
+
+   If byteorder is 0, the output string will always start with the
+   Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
+   prepended.
+
+   Note that Py_UNICODE data is being interpreted as UTF-16 reduced to
+   UCS-2. This trick makes it possible to add full UTF-16 capabilities
+   at a later point without compromising the APIs.
+
+*/
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16(
+    PyObject* unicode,          /* Unicode object */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    );
+
+/* --- Unicode-Escape Codecs ---------------------------------------------- */
+
+/* Variant of PyUnicode_DecodeUnicodeEscape that supports partial decoding. */
+PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeStateful(
+        const char *string,     /* Unicode-Escape encoded string */
+        Py_ssize_t length,      /* size of string */
+        const char *errors,     /* error handling */
+        Py_ssize_t *consumed    /* bytes consumed */
+);
+/* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape
+   chars. */
+PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal(
+        const char *string,     /* Unicode-Escape encoded string */
+        Py_ssize_t length,      /* size of string */
+        const char *errors,     /* error handling */
+        Py_ssize_t *consumed,   /* bytes consumed */
+        const char **first_invalid_escape  /* on return, points to first
+                                              invalid escaped char in
+                                              string. */
+);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length           /* Number of Py_UNICODE chars to encode */
+    );
+
+/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length           /* Number of Py_UNICODE chars to encode */
+    );
+
+/* Variant of PyUnicode_DecodeRawUnicodeEscape that supports partial decoding. */
+PyAPI_FUNC(PyObject*) _PyUnicode_DecodeRawUnicodeEscapeStateful(
+        const char *string,     /* Unicode-Escape encoded string */
+        Py_ssize_t length,      /* size of string */
+        const char *errors,     /* error handling */
+        Py_ssize_t *consumed    /* bytes consumed */
+);
+
+/* --- Latin-1 Codecs ----------------------------------------------------- */
+
+PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String(
+    PyObject* unicode,
+    const char* errors);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+
+/* --- ASCII Codecs ------------------------------------------------------- */
+
+PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString(
+    PyObject* unicode,
+    const char* errors);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+
+/* --- Character Map Codecs ----------------------------------------------- */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    PyObject *mapping,          /* encoding mapping */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap(
+    PyObject *unicode,          /* Unicode object */
+    PyObject *mapping,          /* encoding mapping */
+    const char *errors          /* error handling */
+    );
+
+/* Translate a Py_UNICODE buffer of the given length by applying a
+   character mapping table to it and return the resulting Unicode
+   object.
+
+   The mapping table must map Unicode ordinal integers to Unicode strings,
+   Unicode ordinal integers or None (causing deletion of the character).
+
+   Mapping tables may be dictionaries or sequences. Unmapped character
+   ordinals (ones which cause a LookupError) are left untouched and
+   are copied as-is.
+
+*/
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    PyObject *table,            /* Translate table */
+    const char *errors          /* error handling */
+    );
+
+/* --- MBCS codecs for Windows -------------------------------------------- */
+
+#ifdef MS_WINDOWS
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+#endif
+
+/* --- Decimal Encoder ---------------------------------------------------- */
+
+/* Takes a Unicode string holding a decimal value and writes it into
+   an output buffer using standard ASCII digit codes.
+
+   The output buffer has to provide at least length+1 bytes of storage
+   area. The output string is 0-terminated.
+
+   The encoder converts whitespace to ' ', decimal characters to their
+   corresponding ASCII digit and all other Latin-1 characters except
+   \0 as-is. Characters outside this range (Unicode ordinals 1-256)
+   are treated as errors. This includes embedded NULL bytes.
+
+   Error handling is defined by the errors argument:
+
+      NULL or "strict": raise a ValueError
+      "ignore": ignore the wrong characters (these are not copied to the
+                output buffer)
+      "replace": replaces illegal characters with '?'
+
+   Returns 0 on success, -1 on failure.
+
+*/
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(int) PyUnicode_EncodeDecimal(
+    Py_UNICODE *s,              /* Unicode buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    char *output,               /* Output buffer; must have size >= length */
+    const char *errors          /* error handling */
+    );
+
+/* Transforms code points that have decimal digit property to the
+   corresponding ASCII digit code points.
+
+   Returns a new Unicode string on success, NULL on failure.
+*/
+
+Py_DEPRECATED(3.3)
+PyAPI_FUNC(PyObject*) PyUnicode_TransformDecimalToASCII(
+    Py_UNICODE *s,              /* Unicode buffer */
+    Py_ssize_t length           /* Number of Py_UNICODE chars to transform */
+    );
+
+/* Coverts a Unicode object holding a decimal value to an ASCII string
+   for using in int, float and complex parsers.
+   Transforms code points that have decimal digit property to the
+   corresponding ASCII digit code points.  Transforms spaces to ASCII.
+   Transforms code points starting from the first non-ASCII code point that
+   is neither a decimal digit nor a space to the end into '?'. */
+
+PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* --- Methods & Slots ---------------------------------------------------- */
+
+PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray(
+    PyObject *separator,
+    PyObject *const *items,
+    Py_ssize_t seqlen
+    );
+
+/* Test whether a unicode is equal to ASCII identifier.  Return 1 if true,
+   0 otherwise.  The right argument must be ASCII identifier.
+   Any error occurs inside will be cleared before return. */
+PyAPI_FUNC(int) _PyUnicode_EqualToASCIIId(
+    PyObject *left,             /* Left string */
+    _Py_Identifier *right       /* Right identifier */
+    );
+
+/* Test whether a unicode is equal to ASCII string.  Return 1 if true,
+   0 otherwise.  The right argument must be ASCII-encoded string.
+   Any error occurs inside will be cleared before return. */
+PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString(
+    PyObject *left,
+    const char *right           /* ASCII-encoded string */
+    );
+
+/* Externally visible for str.strip(unicode) */
+PyAPI_FUNC(PyObject *) _PyUnicode_XStrip(
+    PyObject *self,
+    int striptype,
+    PyObject *sepobj
+    );
+
+/* Using explicit passed-in values, insert the thousands grouping
+   into the string pointed to by buffer.  For the argument descriptions,
+   see Objects/stringlib/localeutil.h */
+PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping(
+    _PyUnicodeWriter *writer,
+    Py_ssize_t n_buffer,
+    PyObject *digits,
+    Py_ssize_t d_pos,
+    Py_ssize_t n_digits,
+    Py_ssize_t min_width,
+    const char *grouping,
+    PyObject *thousands_sep,
+    Py_UCS4 *maxchar);
+
+/* === Characters Type APIs =============================================== */
+
+/* Helper array used by Py_UNICODE_ISSPACE(). */
+
+PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[];
+
+/* These should not be used directly. Use the Py_UNICODE_IS* and
+   Py_UNICODE_TO* macros instead.
+
+   These APIs are implemented in Objects/unicodectype.c.
+
+*/
+
+PyAPI_FUNC(int) _PyUnicode_IsLowercase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsUppercase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsTitlecase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsXidStart(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsXidContinue(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsWhitespace(
+    const Py_UCS4 ch         /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsLinebreak(
+    const Py_UCS4 ch         /* Unicode character */
+    );
+
+/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToLowerFull(
+    Py_UCS4 ch,       /* Unicode character */
+    Py_UCS4 *res
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToTitleFull(
+    Py_UCS4 ch,       /* Unicode character */
+    Py_UCS4 *res
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToUpperFull(
+    Py_UCS4 ch,       /* Unicode character */
+    Py_UCS4 *res
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToFoldedFull(
+    Py_UCS4 ch,       /* Unicode character */
+    Py_UCS4 *res
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsCaseIgnorable(
+    Py_UCS4 ch         /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsCased(
+    Py_UCS4 ch         /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToDigit(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(double) _PyUnicode_ToNumeric(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsDigit(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsNumeric(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsPrintable(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsAlpha(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(size_t) Py_UNICODE_strlen(
+    const Py_UNICODE *u
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcpy(
+    Py_UNICODE *s1,
+    const Py_UNICODE *s2);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcat(
+    Py_UNICODE *s1, const Py_UNICODE *s2);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strncpy(
+    Py_UNICODE *s1,
+    const Py_UNICODE *s2,
+    size_t n);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(int) Py_UNICODE_strcmp(
+    const Py_UNICODE *s1,
+    const Py_UNICODE *s2
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(int) Py_UNICODE_strncmp(
+    const Py_UNICODE *s1,
+    const Py_UNICODE *s2,
+    size_t n
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strchr(
+    const Py_UNICODE *s,
+    Py_UNICODE c
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strrchr(
+    const Py_UNICODE *s,
+    Py_UNICODE c
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int);
+
+/* Create a copy of a unicode string ending with a nul character. Return NULL
+   and raise a MemoryError exception on memory allocation failure, otherwise
+   return a new allocated buffer (use PyMem_Free() to free the buffer). */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) PyUnicode_AsUnicodeCopy(
+    PyObject *unicode
+    );
+
+/* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/
+PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*);
+
+/* Fast equality check when the inputs are known to be exact unicode types
+   and where the hash values are equal (i.e. a very probable match) */
+PyAPI_FUNC(int) _PyUnicode_EQ(PyObject *, PyObject *);
+
+PyAPI_FUNC(Py_ssize_t) _PyUnicode_ScanIdentifier(PyObject *);
+
+#ifdef __cplusplus
+}
+#endif