Recorded merge of revisions 81032 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/branches/py3k

................
  r81032 | antoine.pitrou | 2010-05-09 17:52:27 +0200 (dim., 09 mai 2010) | 9 lines

  Recorded merge of revisions 81029 via svnmerge from
  svn+ssh://pythondev@svn.python.org/python/trunk

  ........
    r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines

    Untabify C files. Will watch buildbots.
  ........
................

15 files changed, 1437 insertions, 1437 deletions

diff --git a/Include/abstract.h b/Include/abstract.h
index 6d40ef7..6a6c94c 100644
--- a/Include/abstract.h
+++ b/Include/abstract.h
@@ -32,7 +32,7 @@ Problem
 
   If the programmer wants to get an item from another type of object
   that provides sequence behavior, there is no clear way to do it
-  correctly.  
+  correctly.
 
   The persistent programmer may peruse object.h and find that the
   _typeobject structure provides a means of invoking up to (currently
@@ -44,7 +44,7 @@ Problem
   Also, certain semantics, especially memory management semantics, may
   differ by the type of object being used.  Unfortunately, these
   semantics are not clearly described in the current include files.
-  An abstract interface providing more consistent semantics is needed. 
+  An abstract interface providing more consistent semantics is needed.
 
 Proposal
 
@@ -77,7 +77,7 @@ Proposal
     Python distributions.
 
   From the point of view of Python accessing services provided by C
-  modules: 
+  modules:
 
   - "Python module interface": this interface consist of the basic
     routines used to define modules and their members.  Most of the
@@ -133,11 +133,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyObject_Print(PyObject *o, FILE *fp, int flags);
 
-         Print an object, o, on file, fp.  Returns -1 on
-	 error.  The flags argument is used to enable certain printing
-	 options. The only option currently supported is Py_Print_RAW. 
+     Print an object, o, on file, fp.  Returns -1 on
+     error.  The flags argument is used to enable certain printing
+     options. The only option currently supported is Py_Print_RAW.
 
-         (What should be said about Py_Print_RAW?)	
+     (What should be said about Py_Print_RAW?)
 
        */
 
@@ -145,11 +145,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyObject_HasAttrString(PyObject *o, char *attr_name);
 
-         Returns 1 if o has the attribute attr_name, and 0 otherwise.
-	 This is equivalent to the Python expression:
-	 hasattr(o,attr_name). 
+     Returns 1 if o has the attribute attr_name, and 0 otherwise.
+     This is equivalent to the Python expression:
+     hasattr(o,attr_name).
 
-	 This function always succeeds.
+     This function always succeeds.
 
        */
 
@@ -157,9 +157,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      PyObject* PyObject_GetAttrString(PyObject *o, char *attr_name);
 
-	 Retrieve an attributed named attr_name form object o.
-	 Returns the attribute value on success, or NULL on failure.
-	 This is the equivalent of the Python expression: o.attr_name.
+     Retrieve an attributed named attr_name form object o.
+     Returns the attribute value on success, or NULL on failure.
+     This is the equivalent of the Python expression: o.attr_name.
 
        */
 
@@ -167,11 +167,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyObject_HasAttr(PyObject *o, PyObject *attr_name);
 
-         Returns 1 if o has the attribute attr_name, and 0 otherwise.
-	 This is equivalent to the Python expression:
-	 hasattr(o,attr_name). 
+     Returns 1 if o has the attribute attr_name, and 0 otherwise.
+     This is equivalent to the Python expression:
+     hasattr(o,attr_name).
 
-	 This function always succeeds.
+     This function always succeeds.
 
        */
 
@@ -179,9 +179,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name);
 
-	 Retrieve an attributed named attr_name form object o.
-	 Returns the attribute value on success, or NULL on failure.
-	 This is the equivalent of the Python expression: o.attr_name.
+     Retrieve an attributed named attr_name form object o.
+     Returns the attribute value on success, or NULL on failure.
+     This is the equivalent of the Python expression: o.attr_name.
 
        */
 
@@ -190,9 +190,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyObject_SetAttrString(PyObject *o, char *attr_name, PyObject *v);
 
-	 Set the value of the attribute named attr_name, for object o,
-	 to the value, v. Returns -1 on failure.  This is
-	 the equivalent of the Python statement: o.attr_name=v.
+     Set the value of the attribute named attr_name, for object o,
+     to the value, v. Returns -1 on failure.  This is
+     the equivalent of the Python statement: o.attr_name=v.
 
        */
 
@@ -200,9 +200,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v);
 
-	 Set the value of the attribute named attr_name, for object o,
-	 to the value, v. Returns -1 on failure.  This is
-	 the equivalent of the Python statement: o.attr_name=v.
+     Set the value of the attribute named attr_name, for object o,
+     to the value, v. Returns -1 on failure.  This is
+     the equivalent of the Python statement: o.attr_name=v.
 
        */
 
@@ -210,9 +210,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyObject_DelAttrString(PyObject *o, char *attr_name);
 
-	 Delete attribute named attr_name, for object o. Returns
-	 -1 on failure.  This is the equivalent of the Python
-	 statement: del o.attr_name.
+     Delete attribute named attr_name, for object o. Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: del o.attr_name.
 
        */
 #define  PyObject_DelAttrString(O,A) PyObject_SetAttrString((O),(A),NULL)
@@ -221,9 +221,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyObject_DelAttr(PyObject *o, PyObject *attr_name);
 
-	 Delete attribute named attr_name, for object o. Returns -1
-	 on failure.  This is the equivalent of the Python
-	 statement: del o.attr_name.
+     Delete attribute named attr_name, for object o. Returns -1
+     on failure.  This is the equivalent of the Python
+     statement: del o.attr_name.
 
        */
 #define  PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A),NULL)
@@ -232,11 +232,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      PyObject *PyObject_Repr(PyObject *o);
 
-	 Compute the string representation of object, o.  Returns the
-	 string representation on success, NULL on failure.  This is
-	 the equivalent of the Python expression: repr(o).
+     Compute the string representation of object, o.  Returns the
+     string representation on success, NULL on failure.  This is
+     the equivalent of the Python expression: repr(o).
 
-	 Called by the repr() built-in function.
+     Called by the repr() built-in function.
 
        */
 
@@ -244,11 +244,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      PyObject *PyObject_Str(PyObject *o);
 
-	 Compute the string representation of object, o.  Returns the
-	 string representation on success, NULL on failure.  This is
-	 the equivalent of the Python expression: str(o).)
+     Compute the string representation of object, o.  Returns the
+     string representation on success, NULL on failure.  This is
+     the equivalent of the Python expression: str(o).)
 
-	 Called by the str() and print() built-in functions.
+     Called by the str() and print() built-in functions.
 
        */
 
@@ -256,42 +256,42 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      PyAPI_FUNC(int) PyCallable_Check(PyObject *o);
 
-	 Determine if the object, o, is callable.  Return 1 if the
-	 object is callable and 0 otherwise.
+     Determine if the object, o, is callable.  Return 1 if the
+     object is callable and 0 otherwise.
 
-	 This function always succeeds.
+     This function always succeeds.
        */
 
      PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable_object,
-					  PyObject *args, PyObject *kw);
+                                          PyObject *args, PyObject *kw);
 
        /*
-	 Call a callable Python object, callable_object, with
-	 arguments and keywords arguments.  The 'args' argument can not be
-	 NULL, but the 'kw' argument can be NULL.
+     Call a callable Python object, callable_object, with
+     arguments and keywords arguments.  The 'args' argument can not be
+     NULL, but the 'kw' argument can be NULL.
        */
-     
+
      PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable_object,
                                                 PyObject *args);
 
        /*
-	 Call a callable Python object, callable_object, with
-	 arguments given by the tuple, args.  If no arguments are
-	 needed, then args may be NULL.  Returns the result of the
-	 call on success, or NULL on failure.  This is the equivalent
-	 of the Python expression: o(*args).
+     Call a callable Python object, callable_object, with
+     arguments given by the tuple, args.  If no arguments are
+     needed, then args may be NULL.  Returns the result of the
+     call on success, or NULL on failure.  This is the equivalent
+     of the Python expression: o(*args).
        */
 
      PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable_object,
                                                   char *format, ...);
 
        /*
-	 Call a callable Python object, callable_object, with a
-	 variable number of C arguments. The C arguments are described
-	 using a mkvalue-style format string. The format may be NULL,
-	 indicating that no arguments are provided.  Returns the
-	 result of the call on success, or NULL on failure.  This is
-	 the equivalent of the Python expression: o(*args).
+     Call a callable Python object, callable_object, with a
+     variable number of C arguments. The C arguments are described
+     using a mkvalue-style format string. The format may be NULL,
+     indicating that no arguments are provided.  Returns the
+     result of the call on success, or NULL on failure.  This is
+     the equivalent of the Python expression: o(*args).
        */
 
 
@@ -299,29 +299,29 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
                                                 char *format, ...);
 
        /*
-	 Call the method named m of object o with a variable number of
-	 C arguments.  The C arguments are described by a mkvalue
-	 format string.  The format may be NULL, indicating that no
-	 arguments are provided. Returns the result of the call on
-	 success, or NULL on failure.  This is the equivalent of the
-	 Python expression: o.method(args).
+     Call the method named m of object o with a variable number of
+     C arguments.  The C arguments are described by a mkvalue
+     format string.  The format may be NULL, indicating that no
+     arguments are provided. Returns the result of the call on
+     success, or NULL on failure.  This is the equivalent of the
+     Python expression: o.method(args).
        */
 
      PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable,
-							 char *format, ...);
+                                                         char *format, ...);
      PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *o,
-						       char *name,
-						       char *format, ...);
+                                                       char *name,
+                                                       char *format, ...);
 
      PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable,
                                                          ...);
 
        /*
-	 Call a callable Python object, callable_object, with a
-	 variable number of C arguments.  The C arguments are provided
-	 as PyObject * values, terminated by a NULL.  Returns the
-	 result of the call on success, or NULL on failure.  This is
-	 the equivalent of the Python expression: o(*args).
+     Call a callable Python object, callable_object, with a
+     variable number of C arguments.  The C arguments are provided
+     as PyObject * values, terminated by a NULL.  Returns the
+     result of the call on success, or NULL on failure.  This is
+     the equivalent of the Python expression: o(*args).
        */
 
 
@@ -329,11 +329,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
                                                        PyObject *method, ...);
 
        /*
-	 Call the method named m of object o with a variable number of
-	 C arguments.  The C arguments are provided as PyObject *
-	 values, terminated by NULL.  Returns the result of the call
-	 on success, or NULL on failure.  This is the equivalent of
-	 the Python expression: o.method(args).
+     Call the method named m of object o with a variable number of
+     C arguments.  The C arguments are provided as PyObject *
+     values, terminated by NULL.  Returns the result of the call
+     on success, or NULL on failure.  This is the equivalent of
+     the Python expression: o.method(args).
        */
 
 
@@ -341,9 +341,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      long PyObject_Hash(PyObject *o);
 
-         Compute and return the hash, hash_value, of an object, o.  On
-	 failure, return -1.  This is the equivalent of the Python
-	 expression: hash(o).
+     Compute and return the hash, hash_value, of an object, o.  On
+     failure, return -1.  This is the equivalent of the Python
+     expression: hash(o).
        */
 
 
@@ -351,35 +351,35 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyObject_IsTrue(PyObject *o);
 
-	 Returns 1 if the object, o, is considered to be true, 0 if o is
-	 considered to be false and -1 on failure. This is equivalent to the
-	 Python expression: not not o
+     Returns 1 if the object, o, is considered to be true, 0 if o is
+     considered to be false and -1 on failure. This is equivalent to the
+     Python expression: not not o
        */
 
      /* Implemented elsewhere:
 
      int PyObject_Not(PyObject *o);
 
-	 Returns 0 if the object, o, is considered to be true, 1 if o is
-	 considered to be false and -1 on failure. This is equivalent to the
-	 Python expression: not o
+     Returns 0 if the object, o, is considered to be true, 1 if o is
+     considered to be false and -1 on failure. This is equivalent to the
+     Python expression: not o
        */
 
      PyAPI_FUNC(PyObject *) PyObject_Type(PyObject *o);
 
        /*
-	 On success, returns a type object corresponding to the object
-	 type of object o. On failure, returns NULL.  This is
-	 equivalent to the Python expression: type(o).
+     On success, returns a type object corresponding to the object
+     type of object o. On failure, returns NULL.  This is
+     equivalent to the Python expression: type(o).
        */
 
      PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o);
 
        /*
-         Return the size of object o.  If the object, o, provides
-	 both sequence and mapping protocols, the sequence size is
-	 returned. On error, -1 is returned.  This is the equivalent
-	 to the Python expression: len(o).
+     Return the size of object o.  If the object, o, provides
+     both sequence and mapping protocols, the sequence size is
+     returned. On error, -1 is returned.  This is the equivalent
+     to the Python expression: len(o).
        */
 
        /* For DLL compatibility */
@@ -390,203 +390,203 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
      PyAPI_FUNC(Py_ssize_t) _PyObject_LengthHint(PyObject *o, Py_ssize_t);
 
        /*
-         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.
+     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(PyObject *) PyObject_GetItem(PyObject *o, PyObject *key);
 
        /*
-	 Return element of o corresponding to the object, key, or NULL
-	 on failure. This is the equivalent of the Python expression:
-	 o[key].
+     Return element of o corresponding to the object, key, or NULL
+     on failure. This is the equivalent of the Python expression:
+     o[key].
        */
 
      PyAPI_FUNC(int) PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v);
 
        /*
-	 Map the object, key, to the value, v.  Returns
-	 -1 on failure.  This is the equivalent of the Python
-	 statement: o[key]=v.
+     Map the object, key, to the value, v.  Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: o[key]=v.
        */
 
      PyAPI_FUNC(int) PyObject_DelItemString(PyObject *o, char *key);
 
        /*
-         Remove the mapping for object, key, from the object *o.
-         Returns -1 on failure.  This is equivalent to
-         the Python statement: del o[key].
+     Remove the mapping for object, key, from the object *o.
+     Returns -1 on failure.  This is equivalent to
+     the Python statement: del o[key].
        */
 
      PyAPI_FUNC(int) PyObject_DelItem(PyObject *o, PyObject *key);
 
        /*
-	 Delete the mapping for key from *o.  Returns -1 on failure.
-	 This is the equivalent of the Python statement: del o[key].
+     Delete the mapping for key from *o.  Returns -1 on failure.
+     This is the equivalent of the Python statement: del o[key].
        */
 
-	/* old buffer API
-	   FIXME:  usage of these should all be replaced in Python itself
-	   but for backwards compatibility we will implement them. 
-	   Their usage without a corresponding "unlock" mechansim
-	   may create issues (but they would already be there). */
+    /* old buffer API
+       FIXME:  usage of these should all be replaced in Python itself
+       but for backwards compatibility we will implement them.
+       Their usage without a corresponding "unlock" mechansim
+       may create issues (but they would already be there). */
 
      PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj,
-					   const char **buffer,
-					   Py_ssize_t *buffer_len);
+                                           const char **buffer,
+                                           Py_ssize_t *buffer_len);
 
-       /* 
-	  Takes an arbitrary object which must support the (character,
-	  single segment) buffer interface and returns a pointer to a
-	  read-only memory location useable as character based input
-	  for subsequent processing.
+       /*
+      Takes an arbitrary object which must support the (character,
+      single segment) buffer interface and returns a pointer to a
+      read-only memory location useable as character based input
+      for subsequent processing.
 
-	  0 is returned on success.  buffer and buffer_len are only
-	  set in case no error occurs. Otherwise, -1 is returned and
-	  an exception set.
+      0 is returned on success.  buffer and buffer_len are only
+      set in case no error occurs. Otherwise, -1 is returned and
+      an exception set.
        */
 
      PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj);
 
-      /*  
-	  Checks whether an arbitrary object supports the (character,
-	  single segment) buffer interface.  Returns 1 on success, 0
-	  on failure.
+      /*
+      Checks whether an arbitrary object supports the (character,
+      single segment) buffer interface.  Returns 1 on success, 0
+      on failure.
       */
 
      PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj,
-					   const void **buffer,
-					   Py_ssize_t *buffer_len);
+                                           const void **buffer,
+                                           Py_ssize_t *buffer_len);
 
-       /* 
-	  Same as PyObject_AsCharBuffer() except that this API expects
-	  (readable, single segment) buffer interface and returns a
-	  pointer to a read-only memory location which can contain
-	  arbitrary data.
+       /*
+      Same as PyObject_AsCharBuffer() except that this API expects
+      (readable, single segment) buffer interface and returns a
+      pointer to a read-only memory location which can contain
+      arbitrary data.
 
-	  0 is returned on success.  buffer and buffer_len are only
-	  set in case no error occurrs.  Otherwise, -1 is returned and
-	  an exception set.
+      0 is returned on success.  buffer and buffer_len are only
+      set in case no error occurrs.  Otherwise, -1 is returned and
+      an exception set.
        */
 
      PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj,
-					    void **buffer,
-					    Py_ssize_t *buffer_len);
+                                            void **buffer,
+                                            Py_ssize_t *buffer_len);
 
-       /* 
-	  Takes an arbitrary object which must support the (writable,
-	  single segment) buffer interface and returns a pointer to a
-	  writable memory location in buffer of size buffer_len.
+       /*
+      Takes an arbitrary object which must support the (writable,
+      single segment) buffer interface and returns a pointer to a
+      writable memory location in buffer of size buffer_len.
 
-	  0 is returned on success.  buffer and buffer_len are only
-	  set in case no error occurrs. Otherwise, -1 is returned and
-	  an exception set.
+      0 is returned on success.  buffer and buffer_len are only
+      set in case no error occurrs. Otherwise, -1 is returned and
+      an exception set.
        */
 
-	/* new buffer API */
+    /* new buffer API */
 
 #define PyObject_CheckBuffer(obj) \
-        (((obj)->ob_type->tp_as_buffer != NULL) &&  \
-         ((obj)->ob_type->tp_as_buffer->bf_getbuffer != NULL))
+    (((obj)->ob_type->tp_as_buffer != NULL) &&  \
+     ((obj)->ob_type->tp_as_buffer->bf_getbuffer != NULL))
 
-	/* Return 1 if the getbuffer function is available, otherwise 
-	   return 0 */
+    /* Return 1 if the getbuffer function is available, otherwise
+       return 0 */
 
-     PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view, 
-					int flags);
+     PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
+                                        int flags);
 
-	/* 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
-        */
+    /* 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(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);
-        
-        /* Get the memory area pointed to by the indices for the buffer given. 
-           Note that view->ndim is the assumed size of indices 
-        */
+
+    /* 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(int) PyBuffer_SizeFromFormat(const char *);
-		
-	/* Return the implied itemsize of the data-format area from a 
-	   struct-style description */
-    
 
-	
+    /* Return the implied itemsize of the data-format area from a
+       struct-style description */
+
+
+
      PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view,
-    					   Py_ssize_t len, char fort);
+                                           Py_ssize_t len, char fort);
 
-     PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf, 
-    					     Py_ssize_t len, char fort);
+     PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf,
+                                             Py_ssize_t len, char fort);
 
 
-	/* 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).
+    /* 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.
+       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
-         */
+
+    /* Copy the data from the src buffer to the buffer of destination
+     */
 
      PyAPI_FUNC(int) PyBuffer_IsContiguous(Py_buffer *view, char fort);
 
 
-     PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, 
-	  					    Py_ssize_t *shape, 
-						    Py_ssize_t *strides,
-	                                            int itemsize,
-	     					    char fort);
+     PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims,
+                                                    Py_ssize_t *shape,
+                                                    Py_ssize_t *strides,
+                                                    int itemsize,
+                                                    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.
-        */
+    /*  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(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf,
-		             	       Py_ssize_t len, int readonly,
-				       int flags);
+                                       Py_ssize_t len, int readonly,
+                                       int flags);
 
-        /* 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.
-         */
+    /* 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(void) PyBuffer_Release(Py_buffer *view);
 
        /* Releases a Py_buffer obtained from getbuffer ParseTuple's s*.
-        */
+    */
 
      PyAPI_FUNC(PyObject *) PyObject_Format(PyObject* obj,
-					    PyObject *format_spec);
+                                            PyObject *format_spec);
        /*
-	 Takes an arbitrary object and returns the result of
-	 calling obj.__format__(format_spec).
+     Takes an arbitrary object and returns the result of
+     calling obj.__format__(format_spec).
        */
 
 /* Iterators */
 
      PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *);
      /* Takes an object and returns an iterator for it.
-        This is typically a new iterator but if the argument
-	is an iterator, this returns itself. */
+    This is typically a new iterator but if the argument
+    is an iterator, this returns itself. */
 
 #define PyIter_Check(obj) \
     ((obj)->ob_type->tp_iternext != NULL && \
@@ -594,314 +594,314 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *);
      /* Takes an iterator object and calls its tp_iternext slot,
-	returning the next value.  If the iterator is exhausted,
-	this returns NULL without setting an exception.
-	NULL with an exception means an error occurred. */
+    returning the next value.  If the iterator is exhausted,
+    this returns NULL without setting an exception.
+    NULL with an exception means an error occurred. */
 
 /*  Number Protocol:*/
 
      PyAPI_FUNC(int) PyNumber_Check(PyObject *o);
 
        /*
-         Returns 1 if the object, o, provides numeric protocols, and
-	 false otherwise. 
+     Returns 1 if the object, o, provides numeric protocols, and
+     false otherwise.
 
-	 This function always succeeds.
+     This function always succeeds.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Add(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of adding o1 and o2, or null on failure.
-	 This is the equivalent of the Python expression: o1+o2.
+     Returns the result of adding o1 and o2, or null on failure.
+     This is the equivalent of the Python expression: o1+o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Subtract(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of subtracting o2 from o1, or null on
-	 failure.  This is the equivalent of the Python expression:
-	 o1-o2.
+     Returns the result of subtracting o2 from o1, or null on
+     failure.  This is the equivalent of the Python expression:
+     o1-o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Multiply(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of multiplying o1 and o2, or null on
-	 failure.  This is the equivalent of the Python expression:
-	 o1*o2.
+     Returns the result of multiplying o1 and o2, or null on
+     failure.  This is the equivalent of the Python expression:
+     o1*o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_FloorDivide(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of dividing o1 by o2 giving an integral result,
-	 or null on failure.
-	 This is the equivalent of the Python expression: o1//o2.
+     Returns the result of dividing o1 by o2 giving an integral result,
+     or null on failure.
+     This is the equivalent of the Python expression: o1//o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_TrueDivide(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of dividing o1 by o2 giving a float result,
-	 or null on failure.
-	 This is the equivalent of the Python expression: o1/o2.
+     Returns the result of dividing o1 by o2 giving a float result,
+     or null on failure.
+     This is the equivalent of the Python expression: o1/o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Remainder(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the remainder of dividing o1 by o2, or null on
-	 failure.  This is the equivalent of the Python expression:
-	 o1%o2.
+     Returns the remainder of dividing o1 by o2, or null on
+     failure.  This is the equivalent of the Python expression:
+     o1%o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Divmod(PyObject *o1, PyObject *o2);
 
        /*
-	 See the built-in function divmod.  Returns NULL on failure.
-	 This is the equivalent of the Python expression:
-	 divmod(o1,o2).
+     See the built-in function divmod.  Returns NULL on failure.
+     This is the equivalent of the Python expression:
+     divmod(o1,o2).
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Power(PyObject *o1, PyObject *o2,
                                            PyObject *o3);
 
        /*
-	 See the built-in function pow.  Returns NULL on failure.
-	 This is the equivalent of the Python expression:
-	 pow(o1,o2,o3), where o3 is optional.
+     See the built-in function pow.  Returns NULL on failure.
+     This is the equivalent of the Python expression:
+     pow(o1,o2,o3), where o3 is optional.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Negative(PyObject *o);
 
        /*
-	 Returns the negation of o on success, or null on failure.
-	 This is the equivalent of the Python expression: -o.
+     Returns the negation of o on success, or null on failure.
+     This is the equivalent of the Python expression: -o.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Positive(PyObject *o);
 
        /*
-         Returns the (what?) of o on success, or NULL on failure.
-	 This is the equivalent of the Python expression: +o.
+     Returns the (what?) of o on success, or NULL on failure.
+     This is the equivalent of the Python expression: +o.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Absolute(PyObject *o);
 
        /*
-	 Returns the absolute value of o, or null on failure.  This is
-	 the equivalent of the Python expression: abs(o).
+     Returns the absolute value of o, or null on failure.  This is
+     the equivalent of the Python expression: abs(o).
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Invert(PyObject *o);
 
        /*
-	 Returns the bitwise negation of o on success, or NULL on
-	 failure.  This is the equivalent of the Python expression:
-	 ~o.
+     Returns the bitwise negation of o on success, or NULL on
+     failure.  This is the equivalent of the Python expression:
+     ~o.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Lshift(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of left shifting o1 by o2 on success, or
-	 NULL on failure.  This is the equivalent of the Python
-	 expression: o1 << o2.
+     Returns the result of left shifting o1 by o2 on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: o1 << o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Rshift(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of right shifting o1 by o2 on success, or
-	 NULL on failure.  This is the equivalent of the Python
-	 expression: o1 >> o2.
+     Returns the result of right shifting o1 by o2 on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: o1 >> o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_And(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of bitwise and of o1 and o2 on success, or
-	 NULL on failure. This is the equivalent of the Python
-	 expression: o1&o2.
+     Returns the result of bitwise and of o1 and o2 on success, or
+     NULL on failure. This is the equivalent of the Python
+     expression: o1&o2.
 
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Xor(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the bitwise exclusive or of o1 by o2 on success, or
-	 NULL on failure.  This is the equivalent of the Python
-	 expression: o1^o2.
+     Returns the bitwise exclusive or of o1 by o2 on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: o1^o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Or(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of bitwise or on o1 and o2 on success, or
-	 NULL on failure.  This is the equivalent of the Python
-	 expression: o1|o2.
+     Returns the result of bitwise or on o1 and o2 on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: o1|o2.
        */
 
 #define PyIndex_Check(obj) \
    ((obj)->ob_type->tp_as_number != NULL && \
     (obj)->ob_type->tp_as_number->nb_index != NULL)
-        
+
      PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o);
 
        /*
-	 Returns the object converted to a Python long or int
-	 or NULL with an error raised on failure.
+     Returns the object converted to a Python long or int
+     or NULL with an error raised on failure.
        */
 
      PyAPI_FUNC(Py_ssize_t) PyNumber_AsSsize_t(PyObject *o, PyObject *exc);
 
        /*
-         Returns the Integral instance converted to an int. The
-         instance is expected to be int or long or have an __int__
-         method. Steals integral's reference. error_format will be
-         used to create the TypeError if integral isn't actually an
-         Integral instance. error_format should be a format string
-         that can accept a char* naming integral's type.
+     Returns the Integral instance converted to an int. The
+     instance is expected to be int or long or have an __int__
+     method. Steals integral's reference. error_format will be
+     used to create the TypeError if integral isn't actually an
+     Integral instance. error_format should be a format string
+     that can accept a char* naming integral's type.
        */
 
      PyAPI_FUNC(PyObject *) _PyNumber_ConvertIntegralToInt(
-             PyObject *integral,
-             const char* error_format);
+         PyObject *integral,
+         const char* error_format);
 
        /*
-        Returns the object converted to Py_ssize_t by going through
-        PyNumber_Index first.  If an overflow error occurs while
-        converting the int-or-long to Py_ssize_t, then the second argument
-        is the error-type to return.  If it is NULL, then the overflow error
-        is cleared and the value is clipped. 
+    Returns the object converted to Py_ssize_t by going through
+    PyNumber_Index first.  If an overflow error occurs while
+    converting the int-or-long to Py_ssize_t, then the second argument
+    is the error-type to return.  If it is NULL, then the overflow error
+    is cleared and the value is clipped.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Long(PyObject *o);
 
        /*
-	 Returns the o converted to an integer object on success, or
-	 NULL on failure.  This is the equivalent of the Python
-	 expression: int(o).
+     Returns the o converted to an integer object on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: int(o).
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_Float(PyObject *o);
 
        /*
-	 Returns the o converted to a float object on success, or NULL
-	 on failure.  This is the equivalent of the Python expression:
-	 float(o).
+     Returns the o converted to a float object on success, or NULL
+     on failure.  This is the equivalent of the Python expression:
+     float(o).
        */
-	 
+
 /*  In-place variants of (some of) the above number protocol functions */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of adding o2 to o1, possibly in-place, or null
-	 on failure.  This is the equivalent of the Python expression:
-	 o1 += o2.
+     Returns the result of adding o2 to o1, possibly in-place, or null
+     on failure.  This is the equivalent of the Python expression:
+     o1 += o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of subtracting o2 from o1, possibly in-place or
-	 null on failure.  This is the equivalent of the Python expression:
-	 o1 -= o2.
+     Returns the result of subtracting o2 from o1, possibly in-place or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 -= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of multiplying o1 by o2, possibly in-place, or
-	 null on failure.  This is the equivalent of the Python expression:
-	 o1 *= o2.
+     Returns the result of multiplying o1 by o2, possibly in-place, or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 *= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceFloorDivide(PyObject *o1,
-						        PyObject *o2);
+                                                        PyObject *o2);
 
        /*
-	 Returns the result of dividing o1 by o2 giving an integral result,
-	 possibly in-place, or null on failure.
-	 This is the equivalent of the Python expression:
-	 o1 /= o2.
+     Returns the result of dividing o1 by o2 giving an integral result,
+     possibly in-place, or null on failure.
+     This is the equivalent of the Python expression:
+     o1 /= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceTrueDivide(PyObject *o1,
-						       PyObject *o2);
+                                                       PyObject *o2);
 
        /*
-	 Returns the result of dividing o1 by o2 giving a float result,
-	 possibly in-place, or null on failure.
-	 This is the equivalent of the Python expression:
-	 o1 /= o2.
+     Returns the result of dividing o1 by o2 giving a float result,
+     possibly in-place, or null on failure.
+     This is the equivalent of the Python expression:
+     o1 /= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the remainder of dividing o1 by o2, possibly in-place, or
-	 null on failure.  This is the equivalent of the Python expression:
-	 o1 %= o2.
+     Returns the remainder of dividing o1 by o2, possibly in-place, or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 %= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlacePower(PyObject *o1, PyObject *o2,
-     						  PyObject *o3);
+                                                  PyObject *o3);
 
        /*
-	 Returns the result of raising o1 to the power of o2, possibly
-	 in-place, or null on failure.  This is the equivalent of the Python
-	 expression: o1 **= o2, or pow(o1, o2, o3) if o3 is present.
+     Returns the result of raising o1 to the power of o2, possibly
+     in-place, or null on failure.  This is the equivalent of the Python
+     expression: o1 **= o2, or pow(o1, o2, o3) if o3 is present.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of left shifting o1 by o2, possibly in-place, or
-	 null on failure.  This is the equivalent of the Python expression:
-	 o1 <<= o2.
+     Returns the result of left shifting o1 by o2, possibly in-place, or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 <<= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of right shifting o1 by o2, possibly in-place or
-	 null on failure.  This is the equivalent of the Python expression:
-	 o1 >>= o2.
+     Returns the result of right shifting o1 by o2, possibly in-place or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 >>= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of bitwise and of o1 and o2, possibly in-place,
-	 or null on failure. This is the equivalent of the Python
-	 expression: o1 &= o2.
+     Returns the result of bitwise and of o1 and o2, possibly in-place,
+     or null on failure. This is the equivalent of the Python
+     expression: o1 &= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceXor(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the bitwise exclusive or of o1 by o2, possibly in-place, or
-	 null on failure.  This is the equivalent of the Python expression:
-	 o1 ^= o2.
+     Returns the bitwise exclusive or of o1 by o2, possibly in-place, or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 ^= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceOr(PyObject *o1, PyObject *o2);
 
        /*
-	 Returns the result of bitwise or of o1 and o2, possibly in-place,
-	 or null on failure.  This is the equivalent of the Python
-	 expression: o1 |= o2.
+     Returns the result of bitwise or of o1 and o2, possibly in-place,
+     or null on failure.  This is the equivalent of the Python
+     expression: o1 |= o2.
        */
 
      PyAPI_FUNC(PyObject *) PyNumber_ToBase(PyObject *n, int base);
 
        /*
-	 Returns the integer n converted to a string with a base, with a base
-	 marker of 0b, 0o or 0x prefixed if applicable.
-	 If n is not an int object, it is converted with PyNumber_Index first.
+     Returns the integer n converted to a string with a base, with a base
+     marker of 0b, 0o or 0x prefixed if applicable.
+     If n is not an int object, it is converted with PyNumber_Index first.
        */
 
 
@@ -910,16 +910,16 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
      PyAPI_FUNC(int) PySequence_Check(PyObject *o);
 
        /*
-         Return 1 if the object provides sequence protocol, and zero
-	 otherwise.  
+     Return 1 if the object provides sequence protocol, and zero
+     otherwise.
 
-	 This function always succeeds.
+     This function always succeeds.
        */
 
      PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject *o);
 
        /*
-         Return the size of sequence object o, or -1 on failure.
+     Return the size of sequence object o, or -1 on failure.
        */
 
        /* For DLL compatibility */
@@ -931,147 +931,147 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
      PyAPI_FUNC(PyObject *) PySequence_Concat(PyObject *o1, PyObject *o2);
 
        /*
-	 Return the concatenation of o1 and o2 on success, and NULL on
-	 failure.   This is the equivalent of the Python
-	 expression: o1+o2.
+     Return the concatenation of o1 and o2 on success, and NULL on
+     failure.   This is the equivalent of the Python
+     expression: o1+o2.
        */
 
      PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, Py_ssize_t count);
 
        /*
-	 Return the result of repeating sequence object o count times,
-	 or NULL on failure.  This is the equivalent of the Python
-	 expression: o1*count.
+     Return the result of repeating sequence object o count times,
+     or NULL on failure.  This is the equivalent of the Python
+     expression: o1*count.
        */
 
      PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, Py_ssize_t i);
 
        /*
-	 Return the ith element of o, or NULL on failure. This is the
-	 equivalent of the Python expression: o[i].
+     Return the ith element of o, or NULL on failure. This is the
+     equivalent of the Python expression: o[i].
        */
 
      PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
 
        /*
-	 Return the slice of sequence object o between i1 and i2, or
-	 NULL on failure. This is the equivalent of the Python
-	 expression: o[i1:i2].
+     Return the slice of sequence object o between i1 and i2, or
+     NULL on failure. This is the equivalent of the Python
+     expression: o[i1:i2].
        */
 
      PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v);
 
        /*
-	 Assign object v to the ith element of o.  Returns
-	 -1 on failure.  This is the equivalent of the Python
-	 statement: o[i]=v.
+     Assign object v to the ith element of o.  Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: o[i]=v.
        */
 
      PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, Py_ssize_t i);
 
        /*
-	 Delete the ith element of object v.  Returns
-	 -1 on failure.  This is the equivalent of the Python
-	 statement: del o[i].
+     Delete the ith element of object v.  Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: del o[i].
        */
 
      PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2,
                                          PyObject *v);
 
        /*
-         Assign the sequence object, v, to the slice in sequence
-	 object, o, from i1 to i2.  Returns -1 on failure. This is the
-	 equivalent of the Python statement: o[i1:i2]=v.
+     Assign the sequence object, v, to the slice in sequence
+     object, o, from i1 to i2.  Returns -1 on failure. This is the
+     equivalent of the Python statement: o[i1:i2]=v.
        */
 
      PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
 
        /*
-	 Delete the slice in sequence object, o, from i1 to i2.
-	 Returns -1 on failure. This is the equivalent of the Python
-	 statement: del o[i1:i2].
+     Delete the slice in sequence object, o, from i1 to i2.
+     Returns -1 on failure. This is the equivalent of the Python
+     statement: del o[i1:i2].
        */
 
      PyAPI_FUNC(PyObject *) PySequence_Tuple(PyObject *o);
 
        /*
-	 Returns the sequence, o, as a tuple on success, and NULL on failure.
-	 This is equivalent to the Python expression: tuple(o)
+     Returns the sequence, o, as a tuple on success, and NULL on failure.
+     This is equivalent to the Python expression: tuple(o)
        */
 
 
      PyAPI_FUNC(PyObject *) PySequence_List(PyObject *o);
        /*
-	 Returns the sequence, o, as a list on success, and NULL on failure.
-	 This is equivalent to the Python expression: list(o)
+     Returns the sequence, o, as a list on success, and NULL on failure.
+     This is equivalent to the Python expression: list(o)
        */
 
      PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m);
        /*
-         Returns the sequence, o, as a tuple, unless it's already a
-         tuple or list.  Use PySequence_Fast_GET_ITEM to access the
-         members of this list, and PySequence_Fast_GET_SIZE to get its length.
+     Returns the sequence, o, as a tuple, unless it's already a
+     tuple or list.  Use PySequence_Fast_GET_ITEM to access the
+     members of this list, and PySequence_Fast_GET_SIZE to get its length.
 
-         Returns NULL on failure.  If the object does not support iteration,
-         raises a TypeError exception with m as the message text.
+     Returns NULL on failure.  If the object does not support iteration,
+     raises a TypeError exception with m as the message text.
        */
 
 #define PySequence_Fast_GET_SIZE(o) \
-	(PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o))
+    (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o))
        /*
-	 Return the size of o, assuming that o was returned by
-         PySequence_Fast and is not NULL.
+     Return the size of o, assuming that o was returned by
+     PySequence_Fast and is not NULL.
        */
 
 #define PySequence_Fast_GET_ITEM(o, i)\
      (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
        /*
-	 Return the ith element of o, assuming that o was returned by
-         PySequence_Fast, and that i is within bounds.
+     Return the ith element of o, assuming that o was returned by
+     PySequence_Fast, and that i is within bounds.
        */
 
 #define PySequence_ITEM(o, i)\
-	( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) )
+    ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) )
        /* Assume tp_as_sequence and sq_item exist and that i does not
-	  need to be corrected for a negative index
-       */     
+      need to be corrected for a negative index
+       */
 
 #define PySequence_Fast_ITEMS(sf) \
-	(PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \
-			  : ((PyTupleObject *)(sf))->ob_item)
-	/* Return a pointer to the underlying item array for
-           an object retured by PySequence_Fast */
+    (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \
+                      : ((PyTupleObject *)(sf))->ob_item)
+    /* Return a pointer to the underlying item array for
+       an object retured by PySequence_Fast */
 
      PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject *o, PyObject *value);
 
        /*
-         Return the number of occurrences on value on o, that is,
-	 return the number of keys for which o[key]==value.  On
-	 failure, return -1.  This is equivalent to the Python
-	 expression: o.count(value).
+     Return the number of occurrences on value on o, that is,
+     return the number of keys for which o[key]==value.  On
+     failure, return -1.  This is equivalent to the Python
+     expression: o.count(value).
        */
 
      PyAPI_FUNC(int) PySequence_Contains(PyObject *seq, PyObject *ob);
        /*
-         Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
-         Use __contains__ if possible, else _PySequence_IterSearch().
+     Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
+     Use __contains__ if possible, else _PySequence_IterSearch().
        */
 
 #define PY_ITERSEARCH_COUNT    1
 #define PY_ITERSEARCH_INDEX    2
 #define PY_ITERSEARCH_CONTAINS 3
      PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq,
-     					PyObject *obj, int operation);
-	/*
-	  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.
-	*/
+                                        PyObject *obj, int operation);
+    /*
+      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.
+    */
 
 /* For DLL-level backwards compatibility */
 #undef PySequence_In
@@ -1081,17 +1081,17 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 #define PySequence_In PySequence_Contains
 
        /*
-	 Determine if o contains value.  If an item in o is equal to
-	 X, return 1, otherwise return 0.  On error, return -1.  This
-	 is equivalent to the Python expression: value in o.
+     Determine if o contains value.  If an item in o is equal to
+     X, return 1, otherwise return 0.  On error, return -1.  This
+     is equivalent to the Python expression: value in o.
        */
 
      PyAPI_FUNC(Py_ssize_t) PySequence_Index(PyObject *o, PyObject *value);
 
        /*
-	 Return the first index for which o[i]=value.  On error,
-	 return -1.    This is equivalent to the Python
-	 expression: o.index(value).
+     Return the first index for which o[i]=value.  On error,
+     return -1.    This is equivalent to the Python
+     expression: o.index(value).
        */
 
 /* In-place versions of some of the above Sequence functions. */
@@ -1099,18 +1099,18 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
      PyAPI_FUNC(PyObject *) PySequence_InPlaceConcat(PyObject *o1, PyObject *o2);
 
        /*
-	 Append o2 to o1, in-place when possible. Return the resulting
-	 object, which could be o1, or NULL on failure.  This is the
-	 equivalent of the Python expression: o1 += o2.
+     Append o2 to o1, in-place when possible. Return the resulting
+     object, which could be o1, or NULL on failure.  This is the
+     equivalent of the Python expression: o1 += o2.
 
        */
 
      PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count);
 
        /*
-	 Repeat o1 by count, in-place when possible. Return the resulting
-	 object, which could be o1, or NULL on failure.  This is the
-	 equivalent of the Python expression: o1 *= count.
+     Repeat o1 by count, in-place when possible. Return the resulting
+     object, which could be o1, or NULL on failure.  This is the
+     equivalent of the Python expression: o1 *= count.
 
        */
 
@@ -1119,18 +1119,18 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
      PyAPI_FUNC(int) PyMapping_Check(PyObject *o);
 
        /*
-         Return 1 if the object provides mapping protocol, and zero
-	 otherwise.  
+     Return 1 if the object provides mapping protocol, and zero
+     otherwise.
 
-	 This function always succeeds.
+     This function always succeeds.
        */
 
      PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject *o);
 
        /*
-         Returns the number of keys in object o on success, and -1 on
-	 failure.  For objects that do not provide sequence protocol,
-	 this is equivalent to the Python expression: len(o).
+     Returns the number of keys in object o on success, and -1 on
+     failure.  For objects that do not provide sequence protocol,
+     this is equivalent to the Python expression: len(o).
        */
 
        /* For DLL compatibility */
@@ -1143,9 +1143,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyMapping_DelItemString(PyObject *o, char *key);
 
-	 Remove the mapping for object, key, from the object *o.
-	 Returns -1 on failure.  This is equivalent to
-	 the Python statement: del o[key].
+     Remove the mapping for object, key, from the object *o.
+     Returns -1 on failure.  This is equivalent to
+     the Python statement: del o[key].
        */
 #define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K))
 
@@ -1153,71 +1153,71 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      int PyMapping_DelItem(PyObject *o, PyObject *key);
 
-	 Remove the mapping for object, key, from the object *o.
-	 Returns -1 on failure.  This is equivalent to
-	 the Python statement: del o[key].
+     Remove the mapping for object, key, from the object *o.
+     Returns -1 on failure.  This is equivalent to
+     the Python statement: del o[key].
        */
 #define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K))
 
      PyAPI_FUNC(int) PyMapping_HasKeyString(PyObject *o, char *key);
 
        /*
-	 On success, return 1 if the mapping object has the key, key,
-	 and 0 otherwise.  This is equivalent to the Python expression:
-	 key in o. 
+     On success, return 1 if the mapping object has the key, key,
+     and 0 otherwise.  This is equivalent to the Python expression:
+     key in o.
 
-	 This function always succeeds.
+     This function always succeeds.
        */
 
      PyAPI_FUNC(int) PyMapping_HasKey(PyObject *o, PyObject *key);
 
        /*
-	 Return 1 if the mapping object has the key, key,
-	 and 0 otherwise.  This is equivalent to the Python expression:
-	 key in o. 
+     Return 1 if the mapping object has the key, key,
+     and 0 otherwise.  This is equivalent to the Python expression:
+     key in o.
 
-	 This function always succeeds.
+     This function always succeeds.
 
        */
 
      PyAPI_FUNC(PyObject *) PyMapping_Keys(PyObject *o);
 
        /*
-         On success, return a list or tuple of the keys in object o.
-	 On failure, return NULL.
+     On success, return a list or tuple of the keys in object o.
+     On failure, return NULL.
        */
 
      PyAPI_FUNC(PyObject *) PyMapping_Values(PyObject *o);
 
        /*
-         On success, return a list or tuple of the values in object o.
-	 On failure, return NULL.
+     On success, return a list or tuple of the values in object o.
+     On failure, return NULL.
        */
 
      PyAPI_FUNC(PyObject *) PyMapping_Items(PyObject *o);
 
        /*
-         On success, return a list or tuple of the items in object o,
-	 where each item is a tuple containing a key-value pair.  
-	 On failure, return NULL.
+     On success, return a list or tuple of the items in object o,
+     where each item is a tuple containing a key-value pair.
+     On failure, return NULL.
 
        */
 
      PyAPI_FUNC(PyObject *) PyMapping_GetItemString(PyObject *o, char *key);
 
        /*
-	 Return element of o corresponding to the object, key, or NULL
-	 on failure. This is the equivalent of the Python expression:
-	 o[key].
+     Return element of o corresponding to the object, key, or NULL
+     on failure. This is the equivalent of the Python expression:
+     o[key].
        */
 
      PyAPI_FUNC(int) PyMapping_SetItemString(PyObject *o, char *key,
                                             PyObject *value);
 
        /*
-	 Map the object, key, to the value, v.  Returns 
-	 -1 on failure.  This is the equivalent of the Python
-	 statement: o[key]=v.
+     Map the object, key, to the value, v.  Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: o[key]=v.
       */
 
 
diff --git a/Include/ceval.h b/Include/ceval.h
index 7bd8179..6d240e5 100644
--- a/Include/ceval.h
+++ b/Include/ceval.h
@@ -8,7 +8,7 @@ extern "C" {
 /* Interface to random parts in ceval.c */
 
 PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
-	PyObject *, PyObject *, PyObject *);
+    PyObject *, PyObject *, PyObject *);
 
 /* DLL-level Backwards compatibility: */
 #undef PyEval_CallObject
@@ -16,7 +16,7 @@ PyAPI_FUNC(PyObject *) PyEval_CallObject(PyObject *, PyObject *);
 
 /* Inline this */
 #define PyEval_CallObject(func,arg) \
-        PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
+    PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
 
 PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj,
                                            const char *format, ...);
@@ -49,7 +49,7 @@ PyAPI_FUNC(int) Py_MakePendingCalls(void);
      exceeds the current recursion limit. It raises a RuntimeError, and sets
      the "overflowed" flag in the thread state structure. This flag
      temporarily *disables* the normal protection; this allows cleanup code
-     to potentially outgrow the recursion limit while processing the 
+     to potentially outgrow the recursion limit while processing the
      RuntimeError.
    * "last chance" anti-recursion protection is triggered when the recursion
      level exceeds "current recursion limit + 50". By construction, this
@@ -71,12 +71,12 @@ PyAPI_FUNC(void) Py_SetRecursionLimit(int);
 PyAPI_FUNC(int) Py_GetRecursionLimit(void);
 
 #define Py_EnterRecursiveCall(where)  \
-	    (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \
-	     _Py_CheckRecursiveCall(where))
-#define Py_LeaveRecursiveCall()				\
+            (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \
+             _Py_CheckRecursiveCall(where))
+#define Py_LeaveRecursiveCall()                         \
     do{ if(_Py_MakeEndRecCheck(PyThreadState_GET()->recursion_depth))  \
-	  PyThreadState_GET()->overflowed = 0;  \
-	} while(0)
+      PyThreadState_GET()->overflowed = 0;  \
+    } while(0)
 PyAPI_FUNC(int) _Py_CheckRecursiveCall(char *where);
 PyAPI_DATA(int) _Py_CheckRecursionLimit;
 
@@ -87,15 +87,15 @@ PyAPI_DATA(int) _Py_CheckRecursionLimit;
    of _Py_CheckRecursionLimit for _Py_MakeEndRecCheck() to function properly.
 */
 #  define _Py_MakeRecCheck(x)  \
-	(++(x) > (_Py_CheckRecursionLimit += PyThreadState_GET()->overflowed - 1))
+    (++(x) > (_Py_CheckRecursionLimit += PyThreadState_GET()->overflowed - 1))
 #else
 #  define _Py_MakeRecCheck(x)  (++(x) > _Py_CheckRecursionLimit)
 #endif
 
 #define _Py_MakeEndRecCheck(x) \
-	(--(x) < ((_Py_CheckRecursionLimit > 100) \
-		? (_Py_CheckRecursionLimit - 50) \
-		: (3 * (_Py_CheckRecursionLimit >> 2))))
+    (--(x) < ((_Py_CheckRecursionLimit > 100) \
+        ? (_Py_CheckRecursionLimit - 50) \
+        : (3 * (_Py_CheckRecursionLimit >> 2))))
 
 #define Py_ALLOW_RECURSION \
   do { unsigned char _old = PyThreadState_GET()->recursion_critical;\
@@ -122,31 +122,31 @@ PyAPI_DATA(int) _Py_CheckInterval;
    that lasts a long time and doesn't touch Python data) can allow other
    threads to run as follows:
 
-	...preparations here...
-	Py_BEGIN_ALLOW_THREADS
-	...blocking system call here...
-	Py_END_ALLOW_THREADS
-	...interpret result here...
+    ...preparations here...
+    Py_BEGIN_ALLOW_THREADS
+    ...blocking system call here...
+    Py_END_ALLOW_THREADS
+    ...interpret result here...
 
    The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
    {}-surrounded block.
    To leave the block in the middle (e.g., with return), you must insert
    a line containing Py_BLOCK_THREADS before the return, e.g.
 
-	if (...premature_exit...) {
-		Py_BLOCK_THREADS
-		PyErr_SetFromErrno(PyExc_IOError);
-		return NULL;
-	}
+    if (...premature_exit...) {
+        Py_BLOCK_THREADS
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
 
    An alternative is:
 
-	Py_BLOCK_THREADS
-	if (...premature_exit...) {
-		PyErr_SetFromErrno(PyExc_IOError);
-		return NULL;
-	}
-	Py_UNBLOCK_THREADS
+    Py_BLOCK_THREADS
+    if (...premature_exit...) {
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
+    Py_UNBLOCK_THREADS
 
    For convenience, that the value of 'errno' is restored across
    Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.
@@ -175,12 +175,12 @@ PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
 PyAPI_FUNC(void) PyEval_ReInitThreads(void);
 
 #define Py_BEGIN_ALLOW_THREADS { \
-			PyThreadState *_save; \
-			_save = PyEval_SaveThread();
-#define Py_BLOCK_THREADS	PyEval_RestoreThread(_save);
-#define Py_UNBLOCK_THREADS	_save = PyEval_SaveThread();
-#define Py_END_ALLOW_THREADS	PyEval_RestoreThread(_save); \
-		 }
+                        PyThreadState *_save; \
+                        _save = PyEval_SaveThread();
+#define Py_BLOCK_THREADS        PyEval_RestoreThread(_save);
+#define Py_UNBLOCK_THREADS      _save = PyEval_SaveThread();
+#define Py_END_ALLOW_THREADS    PyEval_RestoreThread(_save); \
+                 }
 
 #else /* !WITH_THREAD */
 
diff --git a/Include/datetime.h b/Include/datetime.h
index 4b506b2..cb96799 100644
--- a/Include/datetime.h
+++ b/Include/datetime.h
@@ -11,13 +11,13 @@ extern "C" {
  * big-endian, unless otherwise noted:
  *
  * byte offset
- *  0 		year     2 bytes, 1-9999
- *  2		month    1 byte, 1-12
- *  3 		day      1 byte, 1-31
- *  4		hour     1 byte, 0-23
- *  5 		minute   1 byte, 0-59
- *  6 		second   1 byte, 0-59
- *  7 		usecond  3 bytes, 0-999999
+ *  0           year     2 bytes, 1-9999
+ *  2           month    1 byte, 1-12
+ *  3           day      1 byte, 1-31
+ *  4           hour     1 byte, 0-23
+ *  5           minute   1 byte, 0-59
+ *  6           second   1 byte, 0-59
+ *  7           usecond  3 bytes, 0-999999
  * 10
  */
 
@@ -33,26 +33,26 @@ extern "C" {
 
 typedef struct
 {
-	PyObject_HEAD
-	long hashcode;		/* -1 when unknown */
-	int days;		/* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
-	int seconds;		/* 0 <= seconds < 24*3600 is invariant */
-	int microseconds;	/* 0 <= microseconds < 1000000 is invariant */
+    PyObject_HEAD
+    long hashcode;              /* -1 when unknown */
+    int days;                   /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
+    int seconds;                /* 0 <= seconds < 24*3600 is invariant */
+    int microseconds;           /* 0 <= microseconds < 1000000 is invariant */
 } PyDateTime_Delta;
 
 typedef struct
 {
-	PyObject_HEAD		/* a pure abstract base clase */
+    PyObject_HEAD               /* a pure abstract base clase */
 } PyDateTime_TZInfo;
 
 
 /* The datetime and time types have hashcodes, and an optional tzinfo member,
  * present if and only if hastzinfo is true.
  */
-#define _PyTZINFO_HEAD		\
-	PyObject_HEAD		\
-	long hashcode;		\
-	char hastzinfo;		/* boolean flag */
+#define _PyTZINFO_HEAD          \
+    PyObject_HEAD               \
+    long hashcode;              \
+    char hastzinfo;             /* boolean flag */
 
 /* No _PyDateTime_BaseTZInfo is allocated; it's just to have something
  * convenient to cast to, when getting at the hastzinfo member of objects
@@ -60,7 +60,7 @@ typedef struct
  */
 typedef struct
 {
-	_PyTZINFO_HEAD
+    _PyTZINFO_HEAD
 } _PyDateTime_BaseTZInfo;
 
 /* All time objects are of PyDateTime_TimeType, but that can be allocated
@@ -69,20 +69,20 @@ typedef struct
  * internal struct used to allocate the right amount of space for the
  * "without" case.
  */
-#define _PyDateTime_TIMEHEAD	\
-	_PyTZINFO_HEAD		\
-	unsigned char data[_PyDateTime_TIME_DATASIZE];
+#define _PyDateTime_TIMEHEAD    \
+    _PyTZINFO_HEAD              \
+    unsigned char data[_PyDateTime_TIME_DATASIZE];
 
 typedef struct
 {
-	_PyDateTime_TIMEHEAD
-} _PyDateTime_BaseTime;		/* hastzinfo false */
+    _PyDateTime_TIMEHEAD
+} _PyDateTime_BaseTime;         /* hastzinfo false */
 
 typedef struct
 {
-	_PyDateTime_TIMEHEAD
-	PyObject *tzinfo;
-} PyDateTime_Time;		/* hastzinfo true */
+    _PyDateTime_TIMEHEAD
+    PyObject *tzinfo;
+} PyDateTime_Time;              /* hastzinfo true */
 
 
 /* All datetime objects are of PyDateTime_DateTimeType, but that can be
@@ -92,48 +92,48 @@ typedef struct
  */
 typedef struct
 {
-	_PyTZINFO_HEAD
-	unsigned char data[_PyDateTime_DATE_DATASIZE];
+    _PyTZINFO_HEAD
+    unsigned char data[_PyDateTime_DATE_DATASIZE];
 } PyDateTime_Date;
 
-#define _PyDateTime_DATETIMEHEAD	\
-	_PyTZINFO_HEAD			\
-	unsigned char data[_PyDateTime_DATETIME_DATASIZE];
+#define _PyDateTime_DATETIMEHEAD        \
+    _PyTZINFO_HEAD                      \
+    unsigned char data[_PyDateTime_DATETIME_DATASIZE];
 
 typedef struct
 {
-	_PyDateTime_DATETIMEHEAD
-} _PyDateTime_BaseDateTime;	/* hastzinfo false */
+    _PyDateTime_DATETIMEHEAD
+} _PyDateTime_BaseDateTime;     /* hastzinfo false */
 
 typedef struct
 {
-	_PyDateTime_DATETIMEHEAD
-	PyObject *tzinfo;
-} PyDateTime_DateTime;		/* hastzinfo true */
+    _PyDateTime_DATETIMEHEAD
+    PyObject *tzinfo;
+} PyDateTime_DateTime;          /* hastzinfo true */
 
 
 /* Apply for date and datetime instances. */
 #define PyDateTime_GET_YEAR(o)     ((((PyDateTime_Date*)o)->data[0] << 8) | \
-                                     ((PyDateTime_Date*)o)->data[1])
+                     ((PyDateTime_Date*)o)->data[1])
 #define PyDateTime_GET_MONTH(o)    (((PyDateTime_Date*)o)->data[2])
 #define PyDateTime_GET_DAY(o)      (((PyDateTime_Date*)o)->data[3])
 
 #define PyDateTime_DATE_GET_HOUR(o)        (((PyDateTime_DateTime*)o)->data[4])
 #define PyDateTime_DATE_GET_MINUTE(o)      (((PyDateTime_DateTime*)o)->data[5])
 #define PyDateTime_DATE_GET_SECOND(o)      (((PyDateTime_DateTime*)o)->data[6])
-#define PyDateTime_DATE_GET_MICROSECOND(o) 		\
-	((((PyDateTime_DateTime*)o)->data[7] << 16) |	\
-         (((PyDateTime_DateTime*)o)->data[8] << 8)  |	\
-          ((PyDateTime_DateTime*)o)->data[9])
+#define PyDateTime_DATE_GET_MICROSECOND(o)              \
+    ((((PyDateTime_DateTime*)o)->data[7] << 16) |       \
+     (((PyDateTime_DateTime*)o)->data[8] << 8)  |       \
+      ((PyDateTime_DateTime*)o)->data[9])
 
 /* Apply for time instances. */
 #define PyDateTime_TIME_GET_HOUR(o)        (((PyDateTime_Time*)o)->data[0])
 #define PyDateTime_TIME_GET_MINUTE(o)      (((PyDateTime_Time*)o)->data[1])
 #define PyDateTime_TIME_GET_SECOND(o)      (((PyDateTime_Time*)o)->data[2])
-#define PyDateTime_TIME_GET_MICROSECOND(o) 		\
-	((((PyDateTime_Time*)o)->data[3] << 16) |	\
-         (((PyDateTime_Time*)o)->data[4] << 8)  |	\
-          ((PyDateTime_Time*)o)->data[5])
+#define PyDateTime_TIME_GET_MICROSECOND(o)              \
+    ((((PyDateTime_Time*)o)->data[3] << 16) |           \
+     (((PyDateTime_Time*)o)->data[4] << 8)  |           \
+      ((PyDateTime_Time*)o)->data[5])
 
 
 /* Define structure for C API. */
@@ -148,7 +148,7 @@ typedef struct {
     /* constructors */
     PyObject *(*Date_FromDate)(int, int, int, PyTypeObject*);
     PyObject *(*DateTime_FromDateAndTime)(int, int, int, int, int, int, int,
-            PyObject*, PyTypeObject*);
+        PyObject*, PyTypeObject*);
     PyObject *(*Time_FromTime)(int, int, int, int, PyObject*, PyTypeObject*);
     PyObject *(*Delta_FromDelta)(int, int, int, int, PyTypeObject*);
 
@@ -185,7 +185,7 @@ typedef struct {
 static PyDateTime_CAPI *PyDateTimeAPI;
 
 #define PyDateTime_IMPORT \
-        PyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0)
+    PyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0)
 
 /* Macros for type checking when not building the Python core. */
 #define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType)
@@ -205,30 +205,30 @@ static PyDateTime_CAPI *PyDateTimeAPI;
 
 /* Macros for accessing constructors in a simplified fashion. */
 #define PyDate_FromDate(year, month, day) \
-	PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
+    PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
 
 #define PyDateTime_FromDateAndTime(year, month, day, hour, min, sec, usec) \
-	PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
-		min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
+    PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
+        min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
 
 #define PyTime_FromTime(hour, minute, second, usecond) \
-	PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
-		Py_None, PyDateTimeAPI->TimeType)
+    PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
+        Py_None, PyDateTimeAPI->TimeType)
 
 #define PyDelta_FromDSU(days, seconds, useconds) \
-	PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
-		PyDateTimeAPI->DeltaType)
+    PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
+        PyDateTimeAPI->DeltaType)
 
 /* Macros supporting the DB API. */
 #define PyDateTime_FromTimestamp(args) \
-	PyDateTimeAPI->DateTime_FromTimestamp( \
-		(PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
+    PyDateTimeAPI->DateTime_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
 
 #define PyDate_FromTimestamp(args) \
-	PyDateTimeAPI->Date_FromTimestamp( \
-		(PyObject*) (PyDateTimeAPI->DateType), args)
+    PyDateTimeAPI->Date_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateType), args)
 
-#endif	/* Py_BUILD_CORE */
+#endif  /* Py_BUILD_CORE */
 
 #ifdef __cplusplus
 }
diff --git a/Include/descrobject.h b/Include/descrobject.h
index f06b421..d2fe109 100644
--- a/Include/descrobject.h
+++ b/Include/descrobject.h
@@ -9,27 +9,27 @@ typedef PyObject *(*getter)(PyObject *, void *);
 typedef int (*setter)(PyObject *, PyObject *, void *);
 
 typedef struct PyGetSetDef {
-	char *name;
-	getter get;
-	setter set;
-	char *doc;
-	void *closure;
+    char *name;
+    getter get;
+    setter set;
+    char *doc;
+    void *closure;
 } PyGetSetDef;
 
 typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args,
-				 void *wrapped);
+                                 void *wrapped);
 
 typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args,
-				      void *wrapped, PyObject *kwds);
+                                      void *wrapped, PyObject *kwds);
 
 struct wrapperbase {
-	char *name;
-	int offset;
-	void *function;
-	wrapperfunc wrapper;
-	char *doc;
-	int flags;
-	PyObject *name_strobj;
+    char *name;
+    int offset;
+    void *function;
+    wrapperfunc wrapper;
+    char *doc;
+    int flags;
+    PyObject *name_strobj;
 };
 
 /* Flags for above struct */
@@ -38,33 +38,33 @@ struct wrapperbase {
 /* Various kinds of descriptor objects */
 
 #define PyDescr_COMMON \
-	PyObject_HEAD \
-	PyTypeObject *d_type; \
-	PyObject *d_name
+    PyObject_HEAD \
+    PyTypeObject *d_type; \
+    PyObject *d_name
 
 typedef struct {
-	PyDescr_COMMON;
+    PyDescr_COMMON;
 } PyDescrObject;
 
 typedef struct {
-	PyDescr_COMMON;
-	PyMethodDef *d_method;
+    PyDescr_COMMON;
+    PyMethodDef *d_method;
 } PyMethodDescrObject;
 
 typedef struct {
-	PyDescr_COMMON;
-	struct PyMemberDef *d_member;
+    PyDescr_COMMON;
+    struct PyMemberDef *d_member;
 } PyMemberDescrObject;
 
 typedef struct {
-	PyDescr_COMMON;
-	PyGetSetDef *d_getset;
+    PyDescr_COMMON;
+    PyGetSetDef *d_getset;
 } PyGetSetDescrObject;
 
 typedef struct {
-	PyDescr_COMMON;
-	struct wrapperbase *d_base;
-	void *d_wrapped; /* This can be any function pointer */
+    PyDescr_COMMON;
+    struct wrapperbase *d_base;
+    void *d_wrapped; /* This can be any function pointer */
 } PyWrapperDescrObject;
 
 PyAPI_DATA(PyTypeObject) PyClassMethodDescr_Type;
@@ -77,11 +77,11 @@ PyAPI_DATA(PyTypeObject) PyDictProxy_Type;
 PyAPI_FUNC(PyObject *) PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *,
-					       struct PyMemberDef *);
+                                               struct PyMemberDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *,
-					       struct PyGetSetDef *);
+                                               struct PyGetSetDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *,
-						struct wrapperbase *, void *);
+                                                struct wrapperbase *, void *);
 #define PyDescr_IsData(d) (Py_TYPE(d)->tp_descr_set != NULL)
 
 PyAPI_FUNC(PyObject *) PyDictProxy_New(PyObject *);
diff --git a/Include/dictobject.h b/Include/dictobject.h
index d8c409e..d1b576c 100644
--- a/Include/dictobject.h
+++ b/Include/dictobject.h
@@ -48,13 +48,13 @@ meaning otherwise.
 #define PyDict_MINSIZE 8
 
 typedef struct {
-	/* Cached hash code of me_key.  Note that hash codes are C longs.
-	 * We have to use Py_ssize_t instead because dict_popitem() abuses
-	 * me_hash to hold a search finger.
-	 */
-	Py_ssize_t me_hash;
-	PyObject *me_key;
-	PyObject *me_value;
+    /* Cached hash code of me_key.  Note that hash codes are C longs.
+     * We have to use Py_ssize_t instead because dict_popitem() abuses
+     * me_hash to hold a search finger.
+     */
+    Py_ssize_t me_hash;
+    PyObject *me_key;
+    PyObject *me_value;
 } PyDictEntry;
 
 /*
@@ -68,24 +68,24 @@ it's two-thirds full.
 */
 typedef struct _dictobject PyDictObject;
 struct _dictobject {
-	PyObject_HEAD
-	Py_ssize_t ma_fill;  /* # Active + # Dummy */
-	Py_ssize_t ma_used;  /* # Active */
-
-	/* The table contains ma_mask + 1 slots, and that's a power of 2.
-	 * We store the mask instead of the size because the mask is more
-	 * frequently needed.
-	 */
-	Py_ssize_t ma_mask;
-
-	/* ma_table points to ma_smalltable for small tables, else to
-	 * additional malloc'ed memory.  ma_table is never NULL!  This rule
-	 * saves repeated runtime null-tests in the workhorse getitem and
-	 * setitem calls.
-	 */
-	PyDictEntry *ma_table;
-	PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
-	PyDictEntry ma_smalltable[PyDict_MINSIZE];
+    PyObject_HEAD
+    Py_ssize_t ma_fill;  /* # Active + # Dummy */
+    Py_ssize_t ma_used;  /* # Active */
+
+    /* The table contains ma_mask + 1 slots, and that's a power of 2.
+     * We store the mask instead of the size because the mask is more
+     * frequently needed.
+     */
+    Py_ssize_t ma_mask;
+
+    /* ma_table points to ma_smalltable for small tables, else to
+     * additional malloc'ed memory.  ma_table is never NULL!  This rule
+     * saves repeated runtime null-tests in the workhorse getitem and
+     * setitem calls.
+     */
+    PyDictEntry *ma_table;
+    PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
+    PyDictEntry ma_smalltable[PyDict_MINSIZE];
 };
 
 PyAPI_DATA(PyTypeObject) PyDict_Type;
@@ -104,7 +104,7 @@ PyAPI_DATA(PyTypeObject) PyDictValues_Type;
 #define PyDictValues_Check(op) (Py_TYPE(op) == &PyDictValues_Type)
 /* This excludes Values, since they are not sets. */
 # define PyDictViewSet_Check(op) \
-	(PyDictKeys_Check(op) || PyDictItems_Check(op))
+    (PyDictKeys_Check(op) || PyDictItems_Check(op))
 
 
 PyAPI_FUNC(PyObject *) PyDict_New(void);
@@ -114,9 +114,9 @@ PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
 PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key);
 PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
 PyAPI_FUNC(int) PyDict_Next(
-	PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
 PyAPI_FUNC(int) _PyDict_Next(
-	PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
 PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp);
 PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp);
 PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp);
@@ -136,8 +136,8 @@ PyAPI_FUNC(int) PyDict_Update(PyObject *mp, PyObject *other);
    dict.update(other) is equivalent to PyDict_Merge(dict, other, 1).
 */
 PyAPI_FUNC(int) PyDict_Merge(PyObject *mp,
-				   PyObject *other,
-				   int override);
+                                   PyObject *other,
+                                   int override);
 
 /* PyDict_MergeFromSeq2 updates/merges from an iterable object producing
    iterable objects of length 2.  If override is true, the last occurrence
@@ -145,8 +145,8 @@ PyAPI_FUNC(int) PyDict_Merge(PyObject *mp,
    is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1).
 */
 PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d,
-					   PyObject *seq2,
-					   int override);
+                                           PyObject *seq2,
+                                           int override);
 
 PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key);
 PyAPI_FUNC(int) PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item);
diff --git a/Include/object.h b/Include/object.h
index 772bbb3..6e744bc 100644
--- a/Include/object.h
+++ b/Include/object.h
@@ -63,9 +63,9 @@ whose size is determined when the object is allocated.
 
 #ifdef Py_TRACE_REFS
 /* Define pointers to support a doubly-linked list of all live heap objects. */
-#define _PyObject_HEAD_EXTRA		\
-	struct _object *_ob_next;	\
-	struct _object *_ob_prev;
+#define _PyObject_HEAD_EXTRA            \
+    struct _object *_ob_next;           \
+    struct _object *_ob_prev;
 
 #define _PyObject_EXTRA_INIT 0, 0,
 
@@ -75,14 +75,14 @@ whose size is determined when the object is allocated.
 #endif
 
 /* PyObject_HEAD defines the initial segment of every PyObject. */
-#define PyObject_HEAD		        PyObject ob_base;
+#define PyObject_HEAD                   PyObject ob_base;
 
-#define PyObject_HEAD_INIT(type)	\
-	{ _PyObject_EXTRA_INIT		\
-	1, type },
+#define PyObject_HEAD_INIT(type)        \
+    { _PyObject_EXTRA_INIT              \
+    1, type },
 
-#define PyVarObject_HEAD_INIT(type, size)	\
-	{ PyObject_HEAD_INIT(type) size },
+#define PyVarObject_HEAD_INIT(type, size)       \
+    { PyObject_HEAD_INIT(type) size },
 
 /* PyObject_VAR_HEAD defines the initial segment of all variable-size
  * container objects.  These end with a declaration of an array with 1
@@ -99,19 +99,19 @@ whose size is determined when the object is allocated.
  * in addition, be cast to PyVarObject*.
  */
 typedef struct _object {
-	_PyObject_HEAD_EXTRA
-	Py_ssize_t ob_refcnt;
-	struct _typeobject *ob_type;
+    _PyObject_HEAD_EXTRA
+    Py_ssize_t ob_refcnt;
+    struct _typeobject *ob_type;
 } PyObject;
 
 typedef struct {
-	PyObject ob_base;
-	Py_ssize_t ob_size; /* Number of items in variable part */
+    PyObject ob_base;
+    Py_ssize_t ob_size; /* Number of items in variable part */
 } PyVarObject;
 
-#define Py_REFCNT(ob)		(((PyObject*)(ob))->ob_refcnt)
-#define Py_TYPE(ob)		(((PyObject*)(ob))->ob_type)
-#define Py_SIZE(ob)		(((PyVarObject*)(ob))->ob_size)
+#define Py_REFCNT(ob)           (((PyObject*)(ob))->ob_refcnt)
+#define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)
+#define Py_SIZE(ob)             (((PyVarObject*)(ob))->ob_size)
 
 /*
 Type objects contain a string containing the type name (to help somewhat
@@ -142,26 +142,26 @@ typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
 
 /* 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;
-	Py_ssize_t smalltable[2];  /* static store for shape and strides of
-				      mono-dimensional buffers. */
-	void *internal;
+    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;
+    Py_ssize_t smalltable[2];  /* static store for shape and strides of
+                                  mono-dimensional buffers. */
+    void *internal;
 } Py_buffer;
 
 typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
 typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
 
-        /* Flags for getting buffers */
+    /* Flags for getting buffers */
 #define PyBUF_SIMPLE 0
 #define PyBUF_WRITABLE 0x0001
 /*  we used to include an E, backwards compatible alias  */
@@ -198,67 +198,67 @@ typedef int (*visitproc)(PyObject *, void *);
 typedef int (*traverseproc)(PyObject *, visitproc, void *);
 
 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;
+    /* 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;
 } 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;
+    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;
+    lenfunc mp_length;
+    binaryfunc mp_subscript;
+    objobjargproc mp_ass_subscript;
 } PyMappingMethods;
 
 
@@ -286,109 +286,109 @@ typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);
 typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t);
 
 typedef 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;
-	printfunc tp_print;
-	getattrfunc tp_getattr;
-	setattrfunc tp_setattr;
-	void *tp_reserved; /* formerly known as tp_compare */
-	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 */
-	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;
+    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;
+    printfunc tp_print;
+    getattrfunc tp_getattr;
+    setattrfunc tp_setattr;
+    void *tp_reserved; /* formerly known as tp_compare */
+    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 */
+    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;
 
 #ifdef COUNT_ALLOCS
-	/* these must be last and never explicitly initialized */
-	Py_ssize_t tp_allocs;
-	Py_ssize_t tp_frees;
-	Py_ssize_t tp_maxalloc;
-	struct _typeobject *tp_prev;
-	struct _typeobject *tp_next;
+    /* these must be last and never explicitly initialized */
+    Py_ssize_t tp_allocs;
+    Py_ssize_t tp_frees;
+    Py_ssize_t tp_maxalloc;
+    struct _typeobject *tp_prev;
+    struct _typeobject *tp_next;
 #endif
 } PyTypeObject;
 
 
 /* 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;
-	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;
-	/* here are optional user slots, followed by the members. */
+    /* Note: there's a dependency on the order of these members
+       in slotptr() in typeobject.c . */
+    PyTypeObject ht_type;
+    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;
+    /* here are optional user slots, followed by the members. */
 } PyHeapTypeObject;
 
 /* access macro to the members which are floating "behind" the object */
@@ -399,20 +399,20 @@ typedef struct _heaptypeobject {
 /* Generic type check */
 PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject *, PyTypeObject *);
 #define PyObject_TypeCheck(ob, tp) \
-	(Py_TYPE(ob) == (tp) || PyType_IsSubtype(Py_TYPE(ob), (tp)))
+    (Py_TYPE(ob) == (tp) || PyType_IsSubtype(Py_TYPE(ob), (tp)))
 
 PyAPI_DATA(PyTypeObject) PyType_Type; /* built-in 'type' */
 PyAPI_DATA(PyTypeObject) PyBaseObject_Type; /* built-in 'object' */
 PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */
 
 #define PyType_Check(op) \
-	PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
+    PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
 #define PyType_CheckExact(op) (Py_TYPE(op) == &PyType_Type)
 
 PyAPI_FUNC(int) PyType_Ready(PyTypeObject *);
 PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
 PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *,
-					       PyObject *, PyObject *);
+                                               PyObject *, PyObject *);
 PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *);
 PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, char *, PyObject **);
 PyAPI_FUNC(unsigned int) PyType_ClearCache(void);
@@ -439,7 +439,7 @@ PyAPI_FUNC(PyObject *) PyObject_SelfIter(PyObject *);
 PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *);
 PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *,
-					      PyObject *, PyObject *);
+                                              PyObject *, PyObject *);
 PyAPI_FUNC(long) PyObject_Hash(PyObject *);
 PyAPI_FUNC(long) PyObject_HashNotImplemented(PyObject *);
 PyAPI_FUNC(int) PyObject_IsTrue(PyObject *);
@@ -469,7 +469,7 @@ PyAPI_FUNC(long) _Py_HashPointer(void*);
 #define PyObject_REPR(obj) _PyUnicode_AsString(PyObject_Repr(obj))
 
 /* Flag bits for printing: */
-#define Py_PRINT_RAW	1	/* No string quotes etc. */
+#define Py_PRINT_RAW    1       /* No string quotes etc. */
 
 /*
 `Type flags (tp_flags)
@@ -524,20 +524,20 @@ given type object has a specified feature.
 #define Py_TPFLAGS_IS_ABSTRACT (1L<<20)
 
 /* These flags are used to determine if a type is a subclass. */
-#define Py_TPFLAGS_INT_SUBCLASS		(1L<<23)
-#define Py_TPFLAGS_LONG_SUBCLASS	(1L<<24)
-#define Py_TPFLAGS_LIST_SUBCLASS	(1L<<25)
-#define Py_TPFLAGS_TUPLE_SUBCLASS	(1L<<26)
-#define Py_TPFLAGS_BYTES_SUBCLASS	(1L<<27)
-#define Py_TPFLAGS_UNICODE_SUBCLASS	(1L<<28)
-#define Py_TPFLAGS_DICT_SUBCLASS	(1L<<29)
-#define Py_TPFLAGS_BASE_EXC_SUBCLASS	(1L<<30)
-#define Py_TPFLAGS_TYPE_SUBCLASS	(1L<<31)
+#define Py_TPFLAGS_INT_SUBCLASS         (1L<<23)
+#define Py_TPFLAGS_LONG_SUBCLASS        (1L<<24)
+#define Py_TPFLAGS_LIST_SUBCLASS        (1L<<25)
+#define Py_TPFLAGS_TUPLE_SUBCLASS       (1L<<26)
+#define Py_TPFLAGS_BYTES_SUBCLASS       (1L<<27)
+#define Py_TPFLAGS_UNICODE_SUBCLASS     (1L<<28)
+#define Py_TPFLAGS_DICT_SUBCLASS        (1L<<29)
+#define Py_TPFLAGS_BASE_EXC_SUBCLASS    (1L<<30)
+#define Py_TPFLAGS_TYPE_SUBCLASS        (1L<<31)
 
 #define Py_TPFLAGS_DEFAULT  ( \
-                             Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \
-                             Py_TPFLAGS_HAVE_VERSION_TAG | \
-                            0)
+                 Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \
+                 Py_TPFLAGS_HAVE_VERSION_TAG | \
+                0)
 
 #define PyType_HasFeature(t,f)  (((t)->tp_flags & (f)) != 0)
 #define PyType_FastSubclass(t,f)  PyType_HasFeature(t,f)
@@ -589,32 +589,32 @@ environment the global variable trick is not safe.)
 #ifdef Py_REF_DEBUG
 PyAPI_DATA(Py_ssize_t) _Py_RefTotal;
 PyAPI_FUNC(void) _Py_NegativeRefcount(const char *fname,
-					    int lineno, PyObject *op);
+                                            int lineno, PyObject *op);
 PyAPI_FUNC(PyObject *) _PyDict_Dummy(void);
 PyAPI_FUNC(PyObject *) _PySet_Dummy(void);
 PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void);
-#define _Py_INC_REFTOTAL	_Py_RefTotal++
-#define _Py_DEC_REFTOTAL	_Py_RefTotal--
-#define _Py_REF_DEBUG_COMMA	,
-#define _Py_CHECK_REFCNT(OP)					\
-{	if (((PyObject*)OP)->ob_refcnt < 0)				\
-		_Py_NegativeRefcount(__FILE__, __LINE__,	\
-				     (PyObject *)(OP));		\
+#define _Py_INC_REFTOTAL        _Py_RefTotal++
+#define _Py_DEC_REFTOTAL        _Py_RefTotal--
+#define _Py_REF_DEBUG_COMMA     ,
+#define _Py_CHECK_REFCNT(OP)                                    \
+{       if (((PyObject*)OP)->ob_refcnt < 0)                             \
+                _Py_NegativeRefcount(__FILE__, __LINE__,        \
+                                     (PyObject *)(OP));         \
 }
 #else
 #define _Py_INC_REFTOTAL
 #define _Py_DEC_REFTOTAL
 #define _Py_REF_DEBUG_COMMA
-#define _Py_CHECK_REFCNT(OP)	/* a semicolon */;
+#define _Py_CHECK_REFCNT(OP)    /* a semicolon */;
 #endif /* Py_REF_DEBUG */
 
 #ifdef COUNT_ALLOCS
 PyAPI_FUNC(void) inc_count(PyTypeObject *);
 PyAPI_FUNC(void) dec_count(PyTypeObject *);
-#define _Py_INC_TPALLOCS(OP)	inc_count(Py_TYPE(OP))
-#define _Py_INC_TPFREES(OP)	dec_count(Py_TYPE(OP))
-#define _Py_DEC_TPFREES(OP)	Py_TYPE(OP)->tp_frees--
-#define _Py_COUNT_ALLOCS_COMMA	,
+#define _Py_INC_TPALLOCS(OP)    inc_count(Py_TYPE(OP))
+#define _Py_INC_TPFREES(OP)     dec_count(Py_TYPE(OP))
+#define _Py_DEC_TPFREES(OP)     Py_TYPE(OP)->tp_frees--
+#define _Py_COUNT_ALLOCS_COMMA  ,
 #else
 #define _Py_INC_TPALLOCS(OP)
 #define _Py_INC_TPFREES(OP)
@@ -635,30 +635,30 @@ PyAPI_FUNC(void) _Py_AddToAllObjects(PyObject *, int force);
 /* Without Py_TRACE_REFS, there's little enough to do that we expand code
  * inline.
  */
-#define _Py_NewReference(op) (				\
-	_Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA	\
-	_Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA		\
-	Py_REFCNT(op) = 1)
+#define _Py_NewReference(op) (                          \
+    _Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA         \
+    _Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA               \
+    Py_REFCNT(op) = 1)
 
 #define _Py_ForgetReference(op) _Py_INC_TPFREES(op)
 
-#define _Py_Dealloc(op) (				\
-	_Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA	\
-	(*Py_TYPE(op)->tp_dealloc)((PyObject *)(op)))
+#define _Py_Dealloc(op) (                               \
+    _Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA          \
+    (*Py_TYPE(op)->tp_dealloc)((PyObject *)(op)))
 #endif /* !Py_TRACE_REFS */
 
-#define Py_INCREF(op) (				\
-	_Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA	\
-	((PyObject*)(op))->ob_refcnt++)
+#define Py_INCREF(op) (                         \
+    _Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA       \
+    ((PyObject*)(op))->ob_refcnt++)
 
-#define Py_DECREF(op)					\
-	do {						\
-	    if (_Py_DEC_REFTOTAL  _Py_REF_DEBUG_COMMA	\
-		--((PyObject*)(op))->ob_refcnt != 0)	\
-		    _Py_CHECK_REFCNT(op)		\
-	    else					\
-		_Py_Dealloc((PyObject *)(op));		\
-        } while (0)
+#define Py_DECREF(op)                                   \
+    do {                                                \
+        if (_Py_DEC_REFTOTAL  _Py_REF_DEBUG_COMMA       \
+        --((PyObject*)(op))->ob_refcnt != 0)            \
+            _Py_CHECK_REFCNT(op)                        \
+        else                                            \
+        _Py_Dealloc((PyObject *)(op));                  \
+    } while (0)
 
 /* Safely decref `op` and set `op` to NULL, especially useful in tp_clear
  * and tp_dealloc implementatons.
@@ -694,14 +694,14 @@ PyAPI_FUNC(void) _Py_AddToAllObjects(PyObject *, int force);
  * Python integers aren't currently weakly referencable.  Best practice is
  * to use Py_CLEAR() even if you can't think of a reason for why you need to.
  */
-#define Py_CLEAR(op)				\
-        do {                            	\
-                if (op) {			\
-                        PyObject *_py_tmp = (PyObject *)(op);	\
-                        (op) = NULL;		\
-                        Py_DECREF(_py_tmp);	\
-                }				\
-        } while (0)
+#define Py_CLEAR(op)                            \
+    do {                                        \
+        if (op) {                               \
+            PyObject *_py_tmp = (PyObject *)(op);               \
+            (op) = NULL;                        \
+            Py_DECREF(_py_tmp);                 \
+        }                                       \
+    } while (0)
 
 /* Macros to use in case the object pointer may be NULL: */
 #define Py_XINCREF(op) do { if ((op) == NULL) ; else Py_INCREF(op); } while (0)
@@ -813,13 +813,13 @@ bracketing the body of its tp_dealloc function with a pair of macros:
 static void
 mytype_dealloc(mytype *p)
 {
-        ... declarations go here ...
+    ... declarations go here ...
 
- 	PyObject_GC_UnTrack(p);	   // must untrack first
-	Py_TRASHCAN_SAFE_BEGIN(p)
-	... The body of the deallocator goes here, including all calls ...
-	... to Py_DECREF on contained objects.                         ...
-	Py_TRASHCAN_SAFE_END(p)
+    PyObject_GC_UnTrack(p);        // must untrack first
+    Py_TRASHCAN_SAFE_BEGIN(p)
+    ... The body of the deallocator goes here, including all calls ...
+    ... to Py_DECREF on contained objects.                         ...
+    Py_TRASHCAN_SAFE_END(p)
 }
 
 CAUTION:  Never return from the middle of the body!  If the body needs to
@@ -849,16 +849,16 @@ PyAPI_DATA(PyObject *) _PyTrash_delete_later;
 #define PyTrash_UNWIND_LEVEL 50
 
 #define Py_TRASHCAN_SAFE_BEGIN(op) \
-	if (_PyTrash_delete_nesting < PyTrash_UNWIND_LEVEL) { \
-		++_PyTrash_delete_nesting;
-		/* The body of the deallocator is here. */
+    if (_PyTrash_delete_nesting < PyTrash_UNWIND_LEVEL) { \
+        ++_PyTrash_delete_nesting;
+        /* The body of the deallocator is here. */
 #define Py_TRASHCAN_SAFE_END(op) \
-		--_PyTrash_delete_nesting; \
-		if (_PyTrash_delete_later && _PyTrash_delete_nesting <= 0) \
-			_PyTrash_destroy_chain(); \
-	} \
-	else \
-		_PyTrash_deposit_object((PyObject*)op);
+        --_PyTrash_delete_nesting; \
+        if (_PyTrash_delete_later && _PyTrash_delete_nesting <= 0) \
+            _PyTrash_destroy_chain(); \
+    } \
+    else \
+        _PyTrash_deposit_object((PyObject*)op);
 
 #ifdef __cplusplus
 }
diff --git a/Include/objimpl.h b/Include/objimpl.h
index 5a27382..6d5a0c4 100644
--- a/Include/objimpl.h
+++ b/Include/objimpl.h
@@ -101,35 +101,35 @@ PyAPI_FUNC(void) PyObject_Free(void *);
 
 /* Macros */
 #ifdef WITH_PYMALLOC
-#ifdef PYMALLOC_DEBUG	/* WITH_PYMALLOC && PYMALLOC_DEBUG */
+#ifdef PYMALLOC_DEBUG   /* WITH_PYMALLOC && PYMALLOC_DEBUG */
 PyAPI_FUNC(void *) _PyObject_DebugMalloc(size_t nbytes);
 PyAPI_FUNC(void *) _PyObject_DebugRealloc(void *p, size_t nbytes);
 PyAPI_FUNC(void) _PyObject_DebugFree(void *p);
 PyAPI_FUNC(void) _PyObject_DebugDumpAddress(const void *p);
 PyAPI_FUNC(void) _PyObject_DebugCheckAddress(const void *p);
 PyAPI_FUNC(void) _PyObject_DebugMallocStats(void);
-#define PyObject_MALLOC		_PyObject_DebugMalloc
-#define PyObject_Malloc		_PyObject_DebugMalloc
-#define PyObject_REALLOC	_PyObject_DebugRealloc
-#define PyObject_Realloc	_PyObject_DebugRealloc
-#define PyObject_FREE		_PyObject_DebugFree
-#define PyObject_Free		_PyObject_DebugFree
-
-#else	/* WITH_PYMALLOC && ! PYMALLOC_DEBUG */
-#define PyObject_MALLOC		PyObject_Malloc
-#define PyObject_REALLOC	PyObject_Realloc
-#define PyObject_FREE		PyObject_Free
+#define PyObject_MALLOC         _PyObject_DebugMalloc
+#define PyObject_Malloc         _PyObject_DebugMalloc
+#define PyObject_REALLOC        _PyObject_DebugRealloc
+#define PyObject_Realloc        _PyObject_DebugRealloc
+#define PyObject_FREE           _PyObject_DebugFree
+#define PyObject_Free           _PyObject_DebugFree
+
+#else   /* WITH_PYMALLOC && ! PYMALLOC_DEBUG */
+#define PyObject_MALLOC         PyObject_Malloc
+#define PyObject_REALLOC        PyObject_Realloc
+#define PyObject_FREE           PyObject_Free
 #endif
 
-#else	/* ! WITH_PYMALLOC */
-#define PyObject_MALLOC		PyMem_MALLOC
-#define PyObject_REALLOC	PyMem_REALLOC
-#define PyObject_FREE		PyMem_FREE
+#else   /* ! WITH_PYMALLOC */
+#define PyObject_MALLOC         PyMem_MALLOC
+#define PyObject_REALLOC        PyMem_REALLOC
+#define PyObject_FREE           PyMem_FREE
 
-#endif	/* WITH_PYMALLOC */
+#endif  /* WITH_PYMALLOC */
 
-#define PyObject_Del		PyObject_Free
-#define PyObject_DEL		PyObject_FREE
+#define PyObject_Del            PyObject_Free
+#define PyObject_DEL            PyObject_FREE
 
 /*
  * Generic object allocator interface
@@ -144,16 +144,16 @@ PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *);
 PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
 
 #define PyObject_New(type, typeobj) \
-		( (type *) _PyObject_New(typeobj) )
+                ( (type *) _PyObject_New(typeobj) )
 #define PyObject_NewVar(type, typeobj, n) \
-		( (type *) _PyObject_NewVar((typeobj), (n)) )
+                ( (type *) _PyObject_NewVar((typeobj), (n)) )
 
 /* Macros trading binary compatibility for speed. See also pymem.h.
    Note that these macros expect non-NULL object pointers.*/
 #define PyObject_INIT(op, typeobj) \
-	( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
+    ( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
 #define PyObject_INIT_VAR(op, typeobj, size) \
-	( Py_SIZE(op) = (size), PyObject_INIT((op), (typeobj)) )
+    ( Py_SIZE(op) = (size), PyObject_INIT((op), (typeobj)) )
 
 #define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize )
 
@@ -171,17 +171,17 @@ PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
 #   error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2"
 #endif
 
-#define _PyObject_VAR_SIZE(typeobj, nitems)	\
-	(size_t)				\
-	( ( (typeobj)->tp_basicsize +		\
-	    (nitems)*(typeobj)->tp_itemsize +	\
-	    (SIZEOF_VOID_P - 1)			\
-	  ) & ~(SIZEOF_VOID_P - 1)		\
-	)
+#define _PyObject_VAR_SIZE(typeobj, nitems)     \
+    (size_t)                                    \
+    ( ( (typeobj)->tp_basicsize +               \
+        (nitems)*(typeobj)->tp_itemsize +       \
+        (SIZEOF_VOID_P - 1)                     \
+      ) & ~(SIZEOF_VOID_P - 1)                  \
+    )
 
 #define PyObject_NEW(type, typeobj) \
 ( (type *) PyObject_Init( \
-	(PyObject *) PyObject_MALLOC( _PyObject_SIZE(typeobj) ), (typeobj)) )
+    (PyObject *) PyObject_MALLOC( _PyObject_SIZE(typeobj) ), (typeobj)) )
 
 #define PyObject_NEW_VAR(type, typeobj, n) \
 ( (type *) PyObject_InitVar( \
@@ -193,7 +193,7 @@ PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
    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}.
+      in this storage with PyObject_{Init, InitVar}.
 
    PyObject *
    YourObject_New(...)
@@ -202,7 +202,7 @@ PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
 
        op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct));
        if (op == NULL)
-           return PyErr_NoMemory();
+       return PyErr_NoMemory();
 
        PyObject_Init(op, &YourTypeStruct);
 
@@ -229,44 +229,44 @@ PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void);
 
 /* Test if an object has a GC head */
 #define PyObject_IS_GC(o) (PyType_IS_GC(Py_TYPE(o)) && \
-	(Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o)))
+    (Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o)))
 
 PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t);
 #define PyObject_GC_Resize(type, op, n) \
-		( (type *) _PyObject_GC_Resize((PyVarObject *)(op), (n)) )
+                ( (type *) _PyObject_GC_Resize((PyVarObject *)(op), (n)) )
 
 /* for source compatibility with 2.2 */
 #define _PyObject_GC_Del PyObject_GC_Del
 
 /* GC information is stored BEFORE the object structure. */
 typedef union _gc_head {
-	struct {
-		union _gc_head *gc_next;
-		union _gc_head *gc_prev;
-		Py_ssize_t gc_refs;
-	} gc;
-	long double dummy;  /* force worst-case alignment */
+    struct {
+        union _gc_head *gc_next;
+        union _gc_head *gc_prev;
+        Py_ssize_t gc_refs;
+    } gc;
+    long double dummy;  /* force worst-case alignment */
 } PyGC_Head;
 
 extern PyGC_Head *_PyGC_generation0;
 
 #define _Py_AS_GC(o) ((PyGC_Head *)(o)-1)
 
-#define _PyGC_REFS_UNTRACKED			(-2)
-#define _PyGC_REFS_REACHABLE			(-3)
-#define _PyGC_REFS_TENTATIVELY_UNREACHABLE	(-4)
+#define _PyGC_REFS_UNTRACKED                    (-2)
+#define _PyGC_REFS_REACHABLE                    (-3)
+#define _PyGC_REFS_TENTATIVELY_UNREACHABLE      (-4)
 
 /* Tell the GC to track this object.  NB: While the object is tracked the
  * collector it must be safe to call the ob_traverse method. */
 #define _PyObject_GC_TRACK(o) do { \
-	PyGC_Head *g = _Py_AS_GC(o); \
-	if (g->gc.gc_refs != _PyGC_REFS_UNTRACKED) \
-		Py_FatalError("GC object already tracked"); \
-	g->gc.gc_refs = _PyGC_REFS_REACHABLE; \
-	g->gc.gc_next = _PyGC_generation0; \
-	g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
-	g->gc.gc_prev->gc.gc_next = g; \
-	_PyGC_generation0->gc.gc_prev = g; \
+    PyGC_Head *g = _Py_AS_GC(o); \
+    if (g->gc.gc_refs != _PyGC_REFS_UNTRACKED) \
+        Py_FatalError("GC object already tracked"); \
+    g->gc.gc_refs = _PyGC_REFS_REACHABLE; \
+    g->gc.gc_next = _PyGC_generation0; \
+    g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
+    g->gc.gc_prev->gc.gc_next = g; \
+    _PyGC_generation0->gc.gc_prev = g; \
     } while (0);
 
 /* Tell the GC to stop tracking this object.
@@ -274,23 +274,23 @@ extern PyGC_Head *_PyGC_generation0;
  * way to provoke memory errors if calling code is confused.
  */
 #define _PyObject_GC_UNTRACK(o) do { \
-	PyGC_Head *g = _Py_AS_GC(o); \
-	assert(g->gc.gc_refs != _PyGC_REFS_UNTRACKED); \
-	g->gc.gc_refs = _PyGC_REFS_UNTRACKED; \
-	g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \
-	g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \
-	g->gc.gc_next = NULL; \
+    PyGC_Head *g = _Py_AS_GC(o); \
+    assert(g->gc.gc_refs != _PyGC_REFS_UNTRACKED); \
+    g->gc.gc_refs = _PyGC_REFS_UNTRACKED; \
+    g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \
+    g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \
+    g->gc.gc_next = NULL; \
     } while (0);
 
 /* True if the object is currently tracked by the GC. */
 #define _PyObject_GC_IS_TRACKED(o) \
-	((_Py_AS_GC(o))->gc.gc_refs != _PyGC_REFS_UNTRACKED)
- 
+    ((_Py_AS_GC(o))->gc.gc_refs != _PyGC_REFS_UNTRACKED)
+
 /* True if the object may be tracked by the GC in the future, or already is.
    This can be useful to implement some optimizations. */
 #define _PyObject_GC_MAY_BE_TRACKED(obj) \
-	(PyObject_IS_GC(obj) && \
-		(!PyTuple_CheckExact(obj) || _PyObject_GC_IS_TRACKED(obj)))
+    (PyObject_IS_GC(obj) && \
+        (!PyTuple_CheckExact(obj) || _PyObject_GC_IS_TRACKED(obj)))
 
 
 PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t);
@@ -301,9 +301,9 @@ PyAPI_FUNC(void) PyObject_GC_UnTrack(void *);
 PyAPI_FUNC(void) PyObject_GC_Del(void *);
 
 #define PyObject_GC_New(type, typeobj) \
-		( (type *) _PyObject_GC_New(typeobj) )
+                ( (type *) _PyObject_GC_New(typeobj) )
 #define PyObject_GC_NewVar(type, typeobj, n) \
-		( (type *) _PyObject_GC_NewVar((typeobj), (n)) )
+                ( (type *) _PyObject_GC_NewVar((typeobj), (n)) )
 
 
 /* Utility macro to help write tp_traverse functions.
@@ -311,14 +311,14 @@ PyAPI_FUNC(void) PyObject_GC_Del(void *);
  * "visit" and "arg".  This is intended to keep tp_traverse functions
  * looking as much alike as possible.
  */
-#define Py_VISIT(op)							\
-        do { 								\
-                if (op) {						\
-                        int vret = visit((PyObject *)(op), arg);	\
-                        if (vret)					\
-                                return vret;				\
-                }							\
-        } while (0)
+#define Py_VISIT(op)                                                    \
+    do {                                                                \
+        if (op) {                                                       \
+            int vret = visit((PyObject *)(op), arg);                    \
+            if (vret)                                                   \
+                return vret;                                            \
+        }                                                               \
+    } while (0)
 
 /* This is here for the sake of backwards compatibility.  Extensions that
  * use the old GC API will still compile but the objects will not be
@@ -334,7 +334,7 @@ PyAPI_FUNC(void) PyObject_GC_Del(void *);
 #define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0)
 
 #define PyObject_GET_WEAKREFS_LISTPTR(o) \
-	((PyObject **) (((char *) (o)) + Py_TYPE(o)->tp_weaklistoffset))
+    ((PyObject **) (((char *) (o)) + Py_TYPE(o)->tp_weaklistoffset))
 
 #ifdef __cplusplus
 }
diff --git a/Include/pyerrors.h b/Include/pyerrors.h
index aafb2a0..66a7030 100644
--- a/Include/pyerrors.h
+++ b/Include/pyerrors.h
@@ -8,8 +8,8 @@ extern "C" {
 
 /* 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;
+             PyObject *args; PyObject *traceback;\
+             PyObject *context; PyObject *cause;
 
 typedef struct {
     PyException_HEAD
@@ -92,15 +92,15 @@ PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *);
 
 /* */
 
-#define PyExceptionClass_Check(x)					\
-	(PyType_Check((x)) &&						\
-	 PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
+#define PyExceptionClass_Check(x)                                       \
+    (PyType_Check((x)) &&                                               \
+     PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
 
-#define PyExceptionInstance_Check(x)			\
-	PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
+#define PyExceptionInstance_Check(x)                    \
+    PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
 
 #define PyExceptionClass_Name(x) \
-	 ((char *)(((PyTypeObject*)(x))->tp_name))
+     ((char *)(((PyTypeObject*)(x))->tp_name))
 
 #define PyExceptionInstance_Class(x) ((PyObject*)((x)->ob_type))
 
@@ -175,29 +175,29 @@ PyAPI_FUNC(int) PyErr_BadArgument(void);
 PyAPI_FUNC(PyObject *) PyErr_NoMemory(void);
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
-	PyObject *, PyObject *);
+    PyObject *, PyObject *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(PyObject *, const char *);
 #ifdef MS_WINDOWS
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(
-	PyObject *, const Py_UNICODE *);
+    PyObject *, const Py_UNICODE *);
 #endif /* MS_WINDOWS */
 
 PyAPI_FUNC(PyObject *) PyErr_Format(PyObject *, const char *, ...);
 
 #ifdef MS_WINDOWS
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilenameObject(
-	int, const char *);
+    int, const char *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(
-	int, const char *);
+    int, const char *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(
-	int, const Py_UNICODE *);
+    int, const Py_UNICODE *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
-	PyObject *,int, PyObject *);
+    PyObject *,int, PyObject *);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
-	PyObject *,int, const char *);
+    PyObject *,int, const char *);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(
-	PyObject *,int, const Py_UNICODE *);
+    PyObject *,int, const Py_UNICODE *);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);
 #endif /* MS_WINDOWS */
 
@@ -229,15 +229,15 @@ PyAPI_FUNC(PyObject *) PyErr_ProgramText(const char *, int);
 
 /* create a UnicodeDecodeError object */
 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
-	const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+    const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
 
 /* create a UnicodeEncodeError object */
 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(
-	const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+    const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
 
 /* create a UnicodeTranslateError object */
 PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(
-	const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+    const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
 
 /* get the encoding attribute */
 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *);
@@ -280,11 +280,11 @@ PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *);
 /* assign a new value to the reason attribute
    return 0 on success, -1 on failure */
 PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(
-	PyObject *, const char *);
+    PyObject *, const char *);
 PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(
-	PyObject *, const char *);
+    PyObject *, const char *);
 PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
-	PyObject *, const char *);
+    PyObject *, const char *);
 
 
 /* These APIs aren't really part of the error implementation, but
@@ -303,9 +303,9 @@ PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
 
 #include <stdarg.h>
 PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char  *format, ...)
-			Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
 PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char  *format, va_list va)
-			Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
 
 #ifdef __cplusplus
 }
diff --git a/Include/pymacconfig.h b/Include/pymacconfig.h
index 50b429c..9e058c1 100644
--- a/Include/pymacconfig.h
+++ b/Include/pymacconfig.h
@@ -4,7 +4,7 @@
       * This file moves some of the autoconf magic to compile-time
       * when building on MacOSX. This is needed for building 4-way
       * universal binaries and for 64-bit universal binaries because
-      * the values redefined below aren't configure-time constant but 
+      * the values redefined below aren't configure-time constant but
       * only compile-time constant in these scenarios.
       */
 
@@ -34,36 +34,36 @@
 
 #    undef SIZEOF_LONG
 #    ifdef __LP64__
-#	 define SIZEOF__BOOL		1
-#        define SIZEOF__BOOL		1
-#        define SIZEOF_LONG 		8
-#        define SIZEOF_PTHREAD_T 	8
-#        define SIZEOF_SIZE_T 		8
-#        define SIZEOF_TIME_T 		8
-#        define SIZEOF_VOID_P 		8
+#        define SIZEOF__BOOL            1
+#        define SIZEOF__BOOL            1
+#        define SIZEOF_LONG             8
+#        define SIZEOF_PTHREAD_T        8
+#        define SIZEOF_SIZE_T           8
+#        define SIZEOF_TIME_T           8
+#        define SIZEOF_VOID_P           8
 #    else
 #        ifdef __ppc__
-#	    define SIZEOF__BOOL		4
+#           define SIZEOF__BOOL         4
 #        else
-#	    define SIZEOF__BOOL		1
+#           define SIZEOF__BOOL         1
 #        endif
-#        define SIZEOF_LONG 		4
-#        define SIZEOF_PTHREAD_T 	4
-#        define SIZEOF_SIZE_T 		4
-#        define SIZEOF_TIME_T 		4
-#        define SIZEOF_VOID_P 		4
+#        define SIZEOF_LONG             4
+#        define SIZEOF_PTHREAD_T        4
+#        define SIZEOF_SIZE_T           4
+#        define SIZEOF_TIME_T           4
+#        define SIZEOF_VOID_P           4
 #    endif
 
 #    if defined(__LP64__)
-	 /* MacOSX 10.4 (the first release to suppport 64-bit code
-	  * at all) only supports 64-bit in the UNIX layer. 
-	  * Therefore surpress the toolbox-glue in 64-bit mode.
-	  */
+     /* MacOSX 10.4 (the first release to suppport 64-bit code
+      * at all) only supports 64-bit in the UNIX layer.
+      * Therefore surpress the toolbox-glue in 64-bit mode.
+      */
 
-	/* In 64-bit mode setpgrp always has no argments, in 32-bit
-	 * mode that depends on the compilation environment
-	 */
-#	undef SETPGRP_HAVE_ARG
+    /* In 64-bit mode setpgrp always has no argments, in 32-bit
+     * mode that depends on the compilation environment
+     */
+#       undef SETPGRP_HAVE_ARG
 
 #    endif
 
@@ -78,17 +78,17 @@
 # define HAVE_GCC_ASM_FOR_X87
 #endif
 
-	/* 
-	 * The definition in pyconfig.h is only valid on the OS release
-	 * where configure ran on and not necessarily for all systems where
-	 * the executable can be used on. 
-	 * 
-	 * Specifically: OSX 10.4 has limited supported for '%zd', while
-	 * 10.5 has full support for '%zd'. A binary built on 10.5 won't
-	 * work properly on 10.4 unless we surpress the definition
-	 * of PY_FORMAT_SIZE_T
-	 */
-#undef	PY_FORMAT_SIZE_T
+    /*
+     * The definition in pyconfig.h is only valid on the OS release
+     * where configure ran on and not necessarily for all systems where
+     * the executable can be used on.
+     *
+     * Specifically: OSX 10.4 has limited supported for '%zd', while
+     * 10.5 has full support for '%zd'. A binary built on 10.5 won't
+     * work properly on 10.4 unless we surpress the definition
+     * of PY_FORMAT_SIZE_T
+     */
+#undef  PY_FORMAT_SIZE_T
 
 
 #endif /* defined(_APPLE__) */
diff --git a/Include/pyport.h b/Include/pyport.h
index 01b0c3a..6af0f96 100644
--- a/Include/pyport.h
+++ b/Include/pyport.h
@@ -132,20 +132,20 @@ Used in:  PY_LONG_LONG
  * integral type.
  */
 #ifdef HAVE_UINTPTR_T
-typedef uintptr_t	Py_uintptr_t;
-typedef intptr_t	Py_intptr_t;
+typedef uintptr_t       Py_uintptr_t;
+typedef intptr_t        Py_intptr_t;
 
 #elif SIZEOF_VOID_P <= SIZEOF_INT
-typedef unsigned int	Py_uintptr_t;
-typedef int		Py_intptr_t;
+typedef unsigned int    Py_uintptr_t;
+typedef int             Py_intptr_t;
 
 #elif SIZEOF_VOID_P <= SIZEOF_LONG
-typedef unsigned long	Py_uintptr_t;
-typedef long		Py_intptr_t;
+typedef unsigned long   Py_uintptr_t;
+typedef long            Py_intptr_t;
 
 #elif defined(HAVE_LONG_LONG) && (SIZEOF_VOID_P <= SIZEOF_LONG_LONG)
-typedef unsigned PY_LONG_LONG	Py_uintptr_t;
-typedef PY_LONG_LONG		Py_intptr_t;
+typedef unsigned PY_LONG_LONG   Py_uintptr_t;
+typedef PY_LONG_LONG            Py_intptr_t;
 
 #else
 #   error "Python needs a typedef for Py_uintptr_t in pyport.h."
@@ -156,9 +156,9 @@ typedef PY_LONG_LONG		Py_intptr_t;
  * unsigned integral type).  See PEP 353 for details.
  */
 #ifdef HAVE_SSIZE_T
-typedef ssize_t		Py_ssize_t;
+typedef ssize_t         Py_ssize_t;
 #elif SIZEOF_VOID_P == SIZEOF_SIZE_T
-typedef Py_intptr_t	Py_ssize_t;
+typedef Py_intptr_t     Py_ssize_t;
 #else
 #   error "Python needs a typedef for Py_ssize_t in pyport.h."
 #endif
@@ -166,7 +166,7 @@ typedef Py_intptr_t	Py_ssize_t;
 /* Largest possible value of size_t.
    SIZE_MAX is part of C99, so it might be defined on some
    platforms. If it is not defined, (size_t)-1 is a portable
-   definition for C89, due to the way signed->unsigned 
+   definition for C89, due to the way signed->unsigned
    conversion is defined. */
 #ifdef SIZE_MAX
 #define PY_SIZE_MAX SIZE_MAX
@@ -243,7 +243,7 @@ typedef Py_intptr_t	Py_ssize_t;
 /* enable more aggressive optimization for visual studio */
 #pragma optimize("agtw", on)
 #endif
-/* ignore warnings if the compiler decides not to inline a function */ 
+/* ignore warnings if the compiler decides not to inline a function */
 #pragma warning(disable: 4710)
 /* fastest possible local call under MSVC */
 #define Py_LOCAL(type) static type __fastcall
@@ -263,16 +263,16 @@ typedef Py_intptr_t	Py_ssize_t;
  */
 
 #if defined(_MSC_VER)
-#define Py_MEMCPY(target, source, length) do {				\
-		size_t i_, n_ = (length);				\
-		char *t_ = (void*) (target);				\
-		const char *s_ = (void*) (source);			\
-		if (n_ >= 16)						\
-			memcpy(t_, s_, n_);				\
-		else							\
-			for (i_ = 0; i_ < n_; i_++)			\
-				t_[i_] = s_[i_];			\
-	} while (0)
+#define Py_MEMCPY(target, source, length) do {                          \
+        size_t i_, n_ = (length);                                       \
+        char *t_ = (void*) (target);                                    \
+        const char *s_ = (void*) (source);                              \
+        if (n_ >= 16)                                                   \
+            memcpy(t_, s_, n_);                                         \
+        else                                                            \
+            for (i_ = 0; i_ < n_; i_++)                                 \
+                t_[i_] = s_[i_];                                        \
+    } while (0)
 #else
 #define Py_MEMCPY memcpy
 #endif
@@ -383,7 +383,7 @@ extern "C" {
  */
 #ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS
 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \
-	((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J))
+    ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J))
 #else
 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))
 #endif
@@ -403,7 +403,7 @@ extern "C" {
  */
 #ifdef Py_DEBUG
 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \
-	(assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
+    (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
 #else
 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)
 #endif
@@ -423,13 +423,13 @@ extern "C" {
 #define _Py_SET_EDOM_FOR_NAN(X) ;
 #endif
 #define Py_SET_ERRNO_ON_MATH_ERROR(X) \
-	do { \
-		if (errno == 0) { \
-			if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
-				errno = ERANGE; \
-			else _Py_SET_EDOM_FOR_NAN(X) \
-		} \
-	} while(0)
+    do { \
+        if (errno == 0) { \
+            if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
+                errno = ERANGE; \
+            else _Py_SET_EDOM_FOR_NAN(X) \
+        } \
+    } while(0)
 
 /* Py_SET_ERANGE_ON_OVERFLOW(x)
  * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility.
@@ -450,26 +450,26 @@ extern "C" {
  *    This isn't reliable.  See Py_OVERFLOWED comments.
  *    X and Y may be evaluated more than once.
  */
-#define Py_ADJUST_ERANGE1(X)						\
-	do {								\
-		if (errno == 0) {					\
-			if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL)	\
-				errno = ERANGE;				\
-		}							\
-		else if (errno == ERANGE && (X) == 0.0)			\
-			errno = 0;					\
-	} while(0)
-
-#define Py_ADJUST_ERANGE2(X, Y)						\
-	do {								\
-		if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL ||	\
-		    (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) {	\
-				if (errno == 0)				\
-					errno = ERANGE;			\
-		}							\
-		else if (errno == ERANGE)				\
-			errno = 0;					\
-	} while(0)
+#define Py_ADJUST_ERANGE1(X)                                            \
+    do {                                                                \
+        if (errno == 0) {                                               \
+            if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL)              \
+                errno = ERANGE;                                         \
+        }                                                               \
+        else if (errno == ERANGE && (X) == 0.0)                         \
+            errno = 0;                                                  \
+    } while(0)
+
+#define Py_ADJUST_ERANGE2(X, Y)                                         \
+    do {                                                                \
+        if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL ||                \
+            (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) {                \
+                        if (errno == 0)                                 \
+                                errno = ERANGE;                         \
+        }                                                               \
+        else if (errno == ERANGE)                                       \
+            errno = 0;                                                  \
+    } while(0)
 
 /*  The functions _Py_dg_strtod and _Py_dg_dtoa in Python/dtoa.c (which are
  *  required to support the short float repr introduced in Python 3.1) require
@@ -498,18 +498,18 @@ extern "C" {
 #ifdef HAVE_GCC_ASM_FOR_X87
 #define HAVE_PY_SET_53BIT_PRECISION 1
 /* _Py_get/set_387controlword functions are defined in Python/pymath.c */
-#define _Py_SET_53BIT_PRECISION_HEADER				\
-	unsigned short old_387controlword, new_387controlword
-#define _Py_SET_53BIT_PRECISION_START					\
-	do {								\
-		old_387controlword = _Py_get_387controlword();		\
-		new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \
-		if (new_387controlword != old_387controlword)		\
-			_Py_set_387controlword(new_387controlword);	\
-	} while (0)
-#define _Py_SET_53BIT_PRECISION_END				\
-	if (new_387controlword != old_387controlword)		\
-		_Py_set_387controlword(old_387controlword)
+#define _Py_SET_53BIT_PRECISION_HEADER                          \
+    unsigned short old_387controlword, new_387controlword
+#define _Py_SET_53BIT_PRECISION_START                                   \
+    do {                                                                \
+        old_387controlword = _Py_get_387controlword();                  \
+        new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \
+        if (new_387controlword != old_387controlword)                   \
+            _Py_set_387controlword(new_387controlword);                 \
+    } while (0)
+#define _Py_SET_53BIT_PRECISION_END                             \
+    if (new_387controlword != old_387controlword)               \
+        _Py_set_387controlword(old_387controlword)
 #endif
 
 /* default definitions are empty */
@@ -553,7 +553,7 @@ extern "C" {
  *    extern int x() Py_DEPRECATED(2.5);
  */
 #if defined(__GNUC__) && ((__GNUC__ >= 4) || \
-			  (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
+              (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
 #define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))
 #else
 #define Py_DEPRECATED(VERSION_UNUSED)
@@ -573,7 +573,7 @@ extern int gethostname(char *, int);
 #endif
 
 #ifdef HAVE__GETPTY
-#include <sys/types.h>		/* we need to import mode_t */
+#include <sys/types.h>          /* we need to import mode_t */
 extern char * _getpty(int *, int, mode_t, int);
 #endif
 
@@ -654,54 +654,54 @@ extern pid_t forkpty(int *, char *, struct termios *, struct winsize *);
   linkage handling and it uses __declspec().
 */
 #if defined(__CYGWIN__)
-#	define HAVE_DECLSPEC_DLL
+#       define HAVE_DECLSPEC_DLL
 #endif
 
 /* only get special linkage if built as shared or platform is Cygwin */
 #if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)
-#	if defined(HAVE_DECLSPEC_DLL)
-#		ifdef Py_BUILD_CORE
-#			define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
-#			define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
-			/* module init functions inside the core need no external linkage */
-			/* except for Cygwin to handle embedding */
-#			if defined(__CYGWIN__)
-#				define PyMODINIT_FUNC __declspec(dllexport) PyObject*
-#			else /* __CYGWIN__ */
-#				define PyMODINIT_FUNC PyObject*
-#			endif /* __CYGWIN__ */
-#		else /* Py_BUILD_CORE */
-			/* Building an extension module, or an embedded situation */
-			/* public Python functions and data are imported */
-			/* Under Cygwin, auto-import functions to prevent compilation */
-			/* failures similar to http://python.org/doc/FAQ.html#3.24 */
-#			if !defined(__CYGWIN__)
-#				define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
-#			endif /* !__CYGWIN__ */
-#			define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
-			/* module init functions outside the core must be exported */
-#			if defined(__cplusplus)
-#				define PyMODINIT_FUNC extern "C" __declspec(dllexport) PyObject*
-#			else /* __cplusplus */
-#				define PyMODINIT_FUNC __declspec(dllexport) PyObject*
-#			endif /* __cplusplus */
-#		endif /* Py_BUILD_CORE */
-#	endif /* HAVE_DECLSPEC */
+#       if defined(HAVE_DECLSPEC_DLL)
+#               ifdef Py_BUILD_CORE
+#                       define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
+#                       define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
+            /* module init functions inside the core need no external linkage */
+            /* except for Cygwin to handle embedding */
+#                       if defined(__CYGWIN__)
+#                               define PyMODINIT_FUNC __declspec(dllexport) PyObject*
+#                       else /* __CYGWIN__ */
+#                               define PyMODINIT_FUNC PyObject*
+#                       endif /* __CYGWIN__ */
+#               else /* Py_BUILD_CORE */
+            /* Building an extension module, or an embedded situation */
+            /* public Python functions and data are imported */
+            /* Under Cygwin, auto-import functions to prevent compilation */
+            /* failures similar to http://python.org/doc/FAQ.html#3.24 */
+#                       if !defined(__CYGWIN__)
+#                               define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
+#                       endif /* !__CYGWIN__ */
+#                       define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
+            /* module init functions outside the core must be exported */
+#                       if defined(__cplusplus)
+#                               define PyMODINIT_FUNC extern "C" __declspec(dllexport) PyObject*
+#                       else /* __cplusplus */
+#                               define PyMODINIT_FUNC __declspec(dllexport) PyObject*
+#                       endif /* __cplusplus */
+#               endif /* Py_BUILD_CORE */
+#       endif /* HAVE_DECLSPEC */
 #endif /* Py_ENABLE_SHARED */
 
 /* If no external linkage macros defined by now, create defaults */
 #ifndef PyAPI_FUNC
-#	define PyAPI_FUNC(RTYPE) RTYPE
+#       define PyAPI_FUNC(RTYPE) RTYPE
 #endif
 #ifndef PyAPI_DATA
-#	define PyAPI_DATA(RTYPE) extern RTYPE
+#       define PyAPI_DATA(RTYPE) extern RTYPE
 #endif
 #ifndef PyMODINIT_FUNC
-#	if defined(__cplusplus)
-#		define PyMODINIT_FUNC extern "C" PyObject*
-#	else /* __cplusplus */
-#		define PyMODINIT_FUNC PyObject*
-#	endif /* __cplusplus */
+#       if defined(__cplusplus)
+#               define PyMODINIT_FUNC extern "C" PyObject*
+#       else /* __cplusplus */
+#               define PyMODINIT_FUNC PyObject*
+#       endif /* __cplusplus */
 #endif
 
 /* limits.h constants that may be missing */
diff --git a/Include/pythonrun.h b/Include/pythonrun.h
index 09d3ee5..0c380e6 100644
--- a/Include/pythonrun.h
+++ b/Include/pythonrun.h
@@ -17,7 +17,7 @@ extern "C" {
 #define PyCF_IGNORE_COOKIE 0x0800
 
 typedef struct {
-	int cf_flags;  /* bitmask of CO_xxx flags relevant to future */
+    int cf_flags;  /* bitmask of CO_xxx flags relevant to future */
 } PyCompilerFlags;
 
 PyAPI_FUNC(void) Py_SetProgramName(wchar_t *);
@@ -40,33 +40,33 @@ PyAPI_FUNC(int) PyRun_SimpleFileExFlags(FILE *, const char *, int, PyCompilerFla
 PyAPI_FUNC(int) PyRun_InteractiveOneFlags(FILE *, const char *, PyCompilerFlags *);
 PyAPI_FUNC(int) PyRun_InteractiveLoopFlags(FILE *, const char *, PyCompilerFlags *);
 
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(const char *, const char *, 
-						 int, PyCompilerFlags *flags,
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(const char *, const char *,
+                                                 int, PyCompilerFlags *flags,
                                                  PyArena *);
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(FILE *, const char *, 
-					       const char*, int, 
-					       char *, char *,
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(FILE *, const char *,
+                                               const char*, int,
+                                               char *, char *,
                                                PyCompilerFlags *, int *,
                                                PyArena *);
 #define PyParser_SimpleParseString(S, B) \
-        PyParser_SimpleParseStringFlags(S, B, 0)
+    PyParser_SimpleParseStringFlags(S, B, 0)
 #define PyParser_SimpleParseFile(FP, S, B) \
-        PyParser_SimpleParseFileFlags(FP, S, B, 0)
-PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int, 
-							  int);
+    PyParser_SimpleParseFileFlags(FP, S, B, 0)
+PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int,
+                                                          int);
 PyAPI_FUNC(struct _node *) PyParser_SimpleParseFileFlags(FILE *, const char *,
-							int, int);
+                                                        int, int);
 
-PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *, 
-					 PyObject *, PyCompilerFlags *);
+PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *,
+                                         PyObject *, PyCompilerFlags *);
 
-PyAPI_FUNC(PyObject *) PyRun_FileExFlags(FILE *, const char *, int, 
-					 PyObject *, PyObject *, int, 
-					 PyCompilerFlags *);
+PyAPI_FUNC(PyObject *) PyRun_FileExFlags(FILE *, const char *, int,
+                                         PyObject *, PyObject *, int,
+                                         PyCompilerFlags *);
 
 #define Py_CompileString(str, p, s) Py_CompileStringFlags(str, p, s, NULL)
 PyAPI_FUNC(PyObject *) Py_CompileStringFlags(const char *, const char *, int,
-					     PyCompilerFlags *);
+                                             PyCompilerFlags *);
 PyAPI_FUNC(struct symtable *) Py_SymtableString(const char *, const char *, int);
 
 PyAPI_FUNC(void) PyErr_Print(void);
@@ -90,20 +90,20 @@ PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv);
 #define PyRun_String(str, s, g, l) PyRun_StringFlags(str, s, g, l, NULL)
 #define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL)
 #define PyRun_AnyFileEx(fp, name, closeit) \
-	PyRun_AnyFileExFlags(fp, name, closeit, NULL)
+    PyRun_AnyFileExFlags(fp, name, closeit, NULL)
 #define PyRun_AnyFileFlags(fp, name, flags) \
-	PyRun_AnyFileExFlags(fp, name, 0, flags)
+    PyRun_AnyFileExFlags(fp, name, 0, flags)
 #define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL)
 #define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL)
 #define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags(f, p, c, NULL)
 #define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags(f, p, NULL)
 #define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL)
 #define PyRun_File(fp, p, s, g, l) \
-        PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
+    PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
 #define PyRun_FileEx(fp, p, s, g, l, c) \
-        PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
+    PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
 #define PyRun_FileFlags(fp, p, s, g, l, flags) \
-        PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
+    PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
 
 /* In getpath.c */
 PyAPI_FUNC(wchar_t *) Py_GetProgramFullPath(void);
diff --git a/Include/setobject.h b/Include/setobject.h
index 60bd73b..4a9baff 100644
--- a/Include/setobject.h
+++ b/Include/setobject.h
@@ -22,8 +22,8 @@ no meaning otherwise.
 #define PySet_MINSIZE 8
 
 typedef struct {
-	long hash;      /* cached hash code for the entry key */
-	PyObject *key;
+    long hash;      /* cached hash code for the entry key */
+    PyObject *key;
 } setentry;
 
 
@@ -33,27 +33,27 @@ This data structure is shared by set and frozenset objects.
 
 typedef struct _setobject PySetObject;
 struct _setobject {
-	PyObject_HEAD
-
-	Py_ssize_t fill;  /* # Active + # Dummy */
-	Py_ssize_t used;  /* # Active */
-
-	/* The table contains mask + 1 slots, and that's a power of 2.
-	 * We store the mask instead of the size because the mask is more
-	 * frequently needed.
-	 */
-	Py_ssize_t mask;
-
-	/* table points to smalltable for small tables, else to
-	 * additional malloc'ed memory.  table is never NULL!  This rule
-	 * saves repeated runtime null-tests.
-	 */
-	setentry *table;
-	setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
-	setentry smalltable[PySet_MINSIZE];
-
-	long hash;		/* only used by frozenset objects */
-	PyObject *weakreflist;	/* List of weak references */
+    PyObject_HEAD
+
+    Py_ssize_t fill;  /* # Active + # Dummy */
+    Py_ssize_t used;  /* # Active */
+
+    /* The table contains mask + 1 slots, and that's a power of 2.
+     * We store the mask instead of the size because the mask is more
+     * frequently needed.
+     */
+    Py_ssize_t mask;
+
+    /* table points to smalltable for small tables, else to
+     * additional malloc'ed memory.  table is never NULL!  This rule
+     * saves repeated runtime null-tests.
+     */
+    setentry *table;
+    setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
+    setentry smalltable[PySet_MINSIZE];
+
+    long hash;                  /* only used by frozenset objects */
+    PyObject *weakreflist;      /* List of weak references */
 };
 
 PyAPI_DATA(PyTypeObject) PySet_Type;
@@ -69,17 +69,17 @@ PyAPI_DATA(PyTypeObject) PySetIter_Type;
 
 #define PyFrozenSet_CheckExact(ob) (Py_TYPE(ob) == &PyFrozenSet_Type)
 #define PyAnySet_CheckExact(ob) \
-	(Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
+    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
 #define PyAnySet_Check(ob) \
-	(Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
-	  PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
-	  PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
+    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
+      PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
+      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
 #define PySet_Check(ob) \
-	(Py_TYPE(ob) == &PySet_Type || \
-	PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
+    (Py_TYPE(ob) == &PySet_Type || \
+    PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
 #define   PyFrozenSet_Check(ob) \
-	(Py_TYPE(ob) == &PyFrozenSet_Type || \
-	  PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
+    (Py_TYPE(ob) == &PyFrozenSet_Type || \
+      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
 
 PyAPI_FUNC(PyObject *) PySet_New(PyObject *);
 PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *);
diff --git a/Include/structseq.h b/Include/structseq.h
index a482bd8..0b8d387 100644
--- a/Include/structseq.h
+++ b/Include/structseq.h
@@ -8,35 +8,35 @@ extern "C" {
 #endif
 
 typedef struct PyStructSequence_Field {
-	char *name;
-	char *doc;
+    char *name;
+    char *doc;
 } PyStructSequence_Field;
 
 typedef struct PyStructSequence_Desc {
-	char *name;
-	char *doc;
-	struct PyStructSequence_Field *fields;
-	int n_in_sequence;
+    char *name;
+    char *doc;
+    struct PyStructSequence_Field *fields;
+    int n_in_sequence;
 } PyStructSequence_Desc;
 
 extern char* PyStructSequence_UnnamedField;
 
 PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type,
-					   PyStructSequence_Desc *desc);
+                                           PyStructSequence_Desc *desc);
 
 PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type);
 
 typedef struct {
-	PyObject_VAR_HEAD
-	PyObject *ob_item[1];
+    PyObject_VAR_HEAD
+    PyObject *ob_item[1];
 } PyStructSequence;
 
 /* Macro, *only* to be used to fill in brand new objects */
 #define PyStructSequence_SET_ITEM(op, i, v) \
-	(((PyStructSequence *)(op))->ob_item[i] = v)
+    (((PyStructSequence *)(op))->ob_item[i] = v)
 
 #define PyStructSequence_GET_ITEM(op, i) \
-	(((PyStructSequence *)(op))->ob_item[i])
+    (((PyStructSequence *)(op))->ob_item[i])
 
 
 #ifdef __cplusplus
diff --git a/Include/symtable.h b/Include/symtable.h
index b07d77c..9abc5b2 100644
--- a/Include/symtable.h
+++ b/Include/symtable.h
@@ -15,40 +15,40 @@ typedef enum _block_type { FunctionBlock, ClassBlock, ModuleBlock }
 struct _symtable_entry;
 
 struct symtable {
-	const char *st_filename;        /* name of file being compiled */
-	struct _symtable_entry *st_cur; /* current symbol table entry */
-	struct _symtable_entry *st_top; /* symbol table entry for module */
-	PyObject *st_blocks;            /* dict: map AST node addresses
-	                                 *       to symbol table entries */
-	PyObject *st_stack;             /* list: stack of namespace info */
-	PyObject *st_global;            /* borrowed ref to st_top->st_symbols */
-	int st_nblocks;                 /* number of blocks used */
-	PyObject *st_private;           /* name of current class or NULL */
-	PyFutureFeatures *st_future;    /* module's future features */
+    const char *st_filename;        /* name of file being compiled */
+    struct _symtable_entry *st_cur; /* current symbol table entry */
+    struct _symtable_entry *st_top; /* symbol table entry for module */
+    PyObject *st_blocks;            /* dict: map AST node addresses
+                                     *       to symbol table entries */
+    PyObject *st_stack;             /* list: stack of namespace info */
+    PyObject *st_global;            /* borrowed ref to st_top->st_symbols */
+    int st_nblocks;                 /* number of blocks used */
+    PyObject *st_private;           /* name of current class or NULL */
+    PyFutureFeatures *st_future;    /* module's future features */
 };
 
 typedef struct _symtable_entry {
-	PyObject_HEAD
-	PyObject *ste_id;        /* int: key in ste_table->st_blocks */
-	PyObject *ste_symbols;   /* dict: variable names to flags */
-	PyObject *ste_name;      /* string: name of current block */
-	PyObject *ste_varnames;  /* list of variable names */
-	PyObject *ste_children;  /* list of child blocks */
-	_Py_block_ty ste_type;   /* module, class, or function */
-	int ste_unoptimized;     /* false if namespace is optimized */
-	int ste_nested;      /* true if block is nested */
-	unsigned ste_free : 1;        /* true if block has free variables */
-	unsigned ste_child_free : 1;  /* true if a child block has free vars,
-				         including free refs to globals */
-	unsigned ste_generator : 1;   /* true if namespace is a generator */
-	unsigned ste_varargs : 1;     /* true if block has varargs */
-	unsigned ste_varkeywords : 1; /* true if block has varkeywords */
-	unsigned ste_returns_value : 1;  /* true if namespace uses return with
-	                                    an argument */
-	int ste_lineno;          /* first line of block */
-	int ste_opt_lineno;      /* lineno of last exec or import * */
-	int ste_tmpname;         /* counter for listcomp temp vars */
-	struct symtable *ste_table;
+    PyObject_HEAD
+    PyObject *ste_id;        /* int: key in ste_table->st_blocks */
+    PyObject *ste_symbols;   /* dict: variable names to flags */
+    PyObject *ste_name;      /* string: name of current block */
+    PyObject *ste_varnames;  /* list of variable names */
+    PyObject *ste_children;  /* list of child blocks */
+    _Py_block_ty ste_type;   /* module, class, or function */
+    int ste_unoptimized;     /* false if namespace is optimized */
+    int ste_nested;      /* true if block is nested */
+    unsigned ste_free : 1;        /* true if block has free variables */
+    unsigned ste_child_free : 1;  /* true if a child block has free vars,
+                                     including free refs to globals */
+    unsigned ste_generator : 1;   /* true if namespace is a generator */
+    unsigned ste_varargs : 1;     /* true if block has varargs */
+    unsigned ste_varkeywords : 1; /* true if block has varkeywords */
+    unsigned ste_returns_value : 1;  /* true if namespace uses return with
+                                        an argument */
+    int ste_lineno;          /* first line of block */
+    int ste_opt_lineno;      /* lineno of last exec or import * */
+    int ste_tmpname;         /* counter for listcomp temp vars */
+    struct symtable *ste_table;
 } PySTEntryObject;
 
 PyAPI_DATA(PyTypeObject) PySTEntry_Type;
@@ -57,8 +57,8 @@ PyAPI_DATA(PyTypeObject) PySTEntry_Type;
 
 PyAPI_FUNC(int) PyST_GetScope(PySTEntryObject *, PyObject *);
 
-PyAPI_FUNC(struct symtable *) PySymtable_Build(mod_ty, const char *, 
-					      PyFutureFeatures *);
+PyAPI_FUNC(struct symtable *) PySymtable_Build(mod_ty, const char *,
+                                              PyFutureFeatures *);
 PyAPI_FUNC(PySTEntryObject *) PySymtable_Lookup(struct symtable *, void *);
 
 PyAPI_FUNC(void) PySymtable_Free(struct symtable *);
@@ -81,7 +81,7 @@ PyAPI_FUNC(void) PySymtable_Free(struct symtable *);
 #define DEF_BOUND (DEF_LOCAL | DEF_PARAM | DEF_IMPORT)
 
 /* GLOBAL_EXPLICIT and GLOBAL_IMPLICIT are used internally by the symbol
-   table.  GLOBAL is returned from PyST_GetScope() for either of them. 
+   table.  GLOBAL is returned from PyST_GetScope() for either of them.
    It is stored in ste_symbols at bits 12-15.
 */
 #define SCOPE_OFFSET 11
diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h
index 08b518a..d21dd96 100644
--- a/Include/unicodeobject.h
+++ b/Include/unicodeobject.h
@@ -28,14 +28,14 @@ Copyright (c) Corporation for National Research Initiatives.
  *
  * --------------------------------------------------------------------
  * This Unicode String Type is
- * 
+ *
  * Copyright (c) 1999 by Secret Labs AB
  * Copyright (c) 1999 by Fredrik Lundh
- * 
+ *
  * By obtaining, using, and/or copying this software and/or its
  * associated documentation, you agree that you have read, understood,
  * and will comply with the following terms and conditions:
- * 
+ *
  * Permission to use, copy, modify, and distribute this software and its
  * associated documentation for any purpose and without fee is hereby
  * granted, provided that the above copyright notice appears in all
@@ -44,7 +44,7 @@ Copyright (c) Corporation for National Research Initiatives.
  * AB or the author not be used in advertising or publicity pertaining to
  * distribution of the software without specific, written prior
  * permission.
- * 
+ *
  * SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  * FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
@@ -61,7 +61,7 @@ Copyright (c) Corporation for National Research Initiatives.
 /* --- Internal Unicode Format -------------------------------------------- */
 
 /* Python 3.x requires unicode */
-#define Py_USING_UNICODE 
+#define Py_USING_UNICODE
 
 /* FIXME: MvL's new implementation assumes that Py_UNICODE_SIZE is
    properly set, but the default rules below doesn't set it.  I'll
@@ -120,10 +120,10 @@ Copyright (c) Corporation for National Research Initiatives.
  * Use this typedef when you need to represent a UTF-16 surrogate pair
  * as single unsigned integer.
  */
-#if SIZEOF_INT >= 4 
-typedef unsigned int Py_UCS4; 
+#if SIZEOF_INT >= 4
+typedef unsigned int Py_UCS4;
 #elif SIZEOF_LONG >= 4
-typedef unsigned long Py_UCS4; 
+typedef unsigned long Py_UCS4;
 #endif
 
 /* Py_UNICODE is the native Unicode storage format (code unit) used by
@@ -382,7 +382,7 @@ typedef PY_UNICODE_TYPE Py_UNICODE;
 
  */
 #define Py_UNICODE_ISSPACE(ch) \
-	((ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch))
+    ((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)
@@ -408,16 +408,16 @@ typedef PY_UNICODE_TYPE Py_UNICODE;
 
 #define Py_UNICODE_ISALNUM(ch) \
        (Py_UNICODE_ISALPHA(ch) || \
-        Py_UNICODE_ISDECIMAL(ch) || \
-        Py_UNICODE_ISDIGIT(ch) || \
-        Py_UNICODE_ISNUMERIC(ch))
+    Py_UNICODE_ISDECIMAL(ch) || \
+    Py_UNICODE_ISDIGIT(ch) || \
+    Py_UNICODE_ISNUMERIC(ch))
 
-#define Py_UNICODE_COPY(target, source, length)				\
-	Py_MEMCPY((target), (source), (length)*sizeof(Py_UNICODE))
+#define Py_UNICODE_COPY(target, source, length)                         \
+    Py_MEMCPY((target), (source), (length)*sizeof(Py_UNICODE))
 
 #define Py_UNICODE_FILL(target, value, length) \
     do {Py_ssize_t i_; Py_UNICODE *t_ = (target); Py_UNICODE v_ = (value);\
-        for (i_ = 0; i_ < (length); i_++) t_[i_] = v_;\
+    for (i_ = 0; i_ < (length); i_++) t_[i_] = v_;\
     } while (0)
 
 /* Check if substring matches at given offset.  the offset must be
@@ -436,15 +436,15 @@ extern "C" {
 
 typedef struct {
     PyObject_HEAD
-    Py_ssize_t length;		/* Length of raw Unicode data in buffer */
-    Py_UNICODE *str;		/* Raw Unicode buffer */
-    long hash;			/* Hash value; -1 if not set */
-    int state;			/* != 0 if interned. In this case the two
-    				 * references from the dictionary to this object
-    				 * are *not* counted in ob_refcnt. */
-    PyObject *defenc;		/* (Default) Encoded version as Python
-				   string, or NULL; this is used for
-				   implementing the buffer protocol */
+    Py_ssize_t length;          /* Length of raw Unicode data in buffer */
+    Py_UNICODE *str;            /* Raw Unicode buffer */
+    long hash;                  /* Hash value; -1 if not set */
+    int state;                  /* != 0 if interned. In this case the two
+                                 * references from the dictionary to this object
+                                 * are *not* counted in ob_refcnt. */
+    PyObject *defenc;           /* (Default) Encoded version as Python
+                                   string, or NULL; this is used for
+                                   implementing the buffer protocol */
 } PyUnicodeObject;
 
 PyAPI_DATA(PyTypeObject) PyUnicode_Type;
@@ -460,13 +460,13 @@ PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type;
 
 /* Fast access macros */
 #define PyUnicode_GET_SIZE(op) \
-        (assert(PyUnicode_Check(op)),(((PyUnicodeObject *)(op))->length))
+    (assert(PyUnicode_Check(op)),(((PyUnicodeObject *)(op))->length))
 #define PyUnicode_GET_DATA_SIZE(op) \
-        (assert(PyUnicode_Check(op)),(((PyUnicodeObject *)(op))->length * sizeof(Py_UNICODE)))
+    (assert(PyUnicode_Check(op)),(((PyUnicodeObject *)(op))->length * sizeof(Py_UNICODE)))
 #define PyUnicode_AS_UNICODE(op) \
-        (assert(PyUnicode_Check(op)),(((PyUnicodeObject *)(op))->str))
+    (assert(PyUnicode_Check(op)),(((PyUnicodeObject *)(op))->str))
 #define PyUnicode_AS_DATA(op) \
-        (assert(PyUnicode_Check(op)),((const char *)((PyUnicodeObject *)(op))->str))
+    (assert(PyUnicode_Check(op)),((const char *)((PyUnicodeObject *)(op))->str))
 
 /* --- Constants ---------------------------------------------------------- */
 
@@ -482,7 +482,7 @@ PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type;
 /* --- Plain Py_UNICODE --------------------------------------------------- */
 
 /* Create a Unicode Object from the Py_UNICODE buffer u of the given
-   size. 
+   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
@@ -512,13 +512,13 @@ PyAPI_FUNC(PyObject*) PyUnicode_FromString(
    Py_UNICODE buffer. */
 
 PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(
-    PyObject *unicode	 	/* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 
 /* Get the length of the Unicode object. */
 
 PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize(
-    PyObject *unicode	 	/* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 
 /* Get the maximum ordinal for a Unicode character. */
@@ -539,8 +539,8 @@ PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void);
 */
 
 PyAPI_FUNC(int) PyUnicode_Resize(
-    PyObject **unicode,		/* Pointer to the Unicode object */
-    Py_ssize_t length		/* New length */
+    PyObject **unicode,         /* Pointer to the Unicode object */
+    Py_ssize_t length           /* New length */
     );
 
 /* Coerce obj to an Unicode object and return a reference with
@@ -561,14 +561,14 @@ PyAPI_FUNC(int) PyUnicode_Resize(
 */
 
 PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject(
-    register PyObject *obj, 	/* Object */
+    register PyObject *obj,     /* Object */
     const char *encoding,       /* encoding */
     const char *errors          /* error handling */
     );
 
 /* Coerce obj to an Unicode object and return a reference with
    *incremented* refcount.
-   
+
    Unicode objects are passed back as-is (subclasses are converted to
    true Unicode objects), all other objects are delegated to
    PyUnicode_FromEncodedObject(obj, NULL, "strict") which results in
@@ -580,7 +580,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject(
 */
 
 PyAPI_FUNC(PyObject*) PyUnicode_FromObject(
-    register PyObject *obj 	/* Object */
+    register PyObject *obj      /* Object */
     );
 
 PyAPI_FUNC(PyObject *) PyUnicode_FromFormatV(const char*, va_list);
@@ -636,8 +636,8 @@ PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar(
 
 /* --- Unicode ordinals --------------------------------------------------- */
 
-/* Create a Unicode Object from the given Unicode code point ordinal. 
- 
+/* Create a Unicode Object from the given Unicode code point ordinal.
+
    The ordinal must be in range(0x10000) on narrow Python builds
    (UCS2), and range(0x110000) on wide builds (UCS4). A ValueError is
    raised in case it is not.
@@ -657,11 +657,11 @@ PyAPI_FUNC(PyObject*) PyUnicode_FromOrdinal(int ordinal);
 
 PyAPI_FUNC(int) PyUnicode_ClearFreeList(void);
 
-/* === Builtin Codecs ===================================================== 
+/* === Builtin Codecs =====================================================
 
    Many of these APIs take two arguments encoding and errors. These
    parameters encoding and errors have the same semantics as the ones
-   of the builtin unicode() API. 
+   of the builtin unicode() API.
 
    Setting encoding to NULL causes the default encoding to be used.
 
@@ -678,7 +678,7 @@ PyAPI_FUNC(int) PyUnicode_ClearFreeList(void);
 /* --- Manage the default encoding ---------------------------------------- */
 
 /* Return a Python string holding the default encoded value of the
-   Unicode object. 
+   Unicode object.
 
    The resulting string is cached in the Unicode object for subsequent
    usage by this function. The cached version is needed to implement
@@ -710,7 +710,7 @@ PyAPI_FUNC(PyObject *) _PyUnicode_AsDefaultEncodedString(
 */
 
 PyAPI_FUNC(char *) _PyUnicode_AsStringAndSize(
-    PyObject *unicode, 
+    PyObject *unicode,
     Py_ssize_t *size);
 
 /* Returns a pointer to the default encoding (normally, UTf-8) of the
@@ -735,7 +735,7 @@ PyAPI_FUNC(char *) _PyUnicode_AsString(PyObject *unicode);
    process global.  This may change in future versions of the
    interpreter to become a parameter which is managed on a per-thread
    basis.
-   
+
  */
 
 PyAPI_FUNC(const char*) PyUnicode_GetDefaultEncoding(void);
@@ -743,11 +743,11 @@ PyAPI_FUNC(const char*) PyUnicode_GetDefaultEncoding(void);
 /* Sets the currently active default encoding.
 
    Returns 0 on success, -1 in case of an error.
-   
+
  */
 
 PyAPI_FUNC(int) PyUnicode_SetDefaultEncoding(
-    const char *encoding	/* Encoding name in standard form */
+    const char *encoding        /* Encoding name in standard form */
     );
 
 /* --- Generic Codecs ----------------------------------------------------- */
@@ -766,21 +766,21 @@ PyAPI_FUNC(PyObject*) PyUnicode_Decode(
    object. */
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedObject(
-    PyObject *unicode,	 	/* Unicode object */
-    const char *encoding,	/* encoding */
-    const char *errors		/* error handling */
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
     );
 
 /* Decode a Unicode object unicode and return the result as Unicode
    object. */
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedUnicode(
-    PyObject *unicode,	 	/* Unicode object */
-    const char *encoding,	/* encoding */
-    const char *errors		/* error handling */
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
     );
 
-/* Encodes a Py_UNICODE buffer of the given size and returns a 
+/* Encodes a Py_UNICODE buffer of the given size and returns a
    Python string object. */
 
 PyAPI_FUNC(PyObject*) PyUnicode_Encode(
@@ -794,27 +794,27 @@ PyAPI_FUNC(PyObject*) PyUnicode_Encode(
    object. */
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject(
-    PyObject *unicode,	 	/* Unicode object */
-    const char *encoding,	/* encoding */
-    const char *errors		/* error handling */
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
     );
 
 /* Encodes a Unicode object and returns the result as Python string
    object. */
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString(
-    PyObject *unicode,	 	/* Unicode object */
-    const char *encoding,	/* encoding */
-    const char *errors		/* error handling */
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
     );
 
 /* Encodes a Unicode object and returns the result as Unicode
    object. */
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedUnicode(
-    PyObject *unicode,	 	/* Unicode object */
-    const char *encoding,	/* encoding */
-    const char *errors		/* error handling */
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
     );
 
 /* Build an encoding map. */
@@ -826,49 +826,49 @@ PyAPI_FUNC(PyObject*) PyUnicode_BuildEncodingMap(
 /* --- UTF-7 Codecs ------------------------------------------------------- */
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7(
-    const char *string, 	/* UTF-7 encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors		/* error handling */
+    const char *string,         /* UTF-7 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7Stateful(
-    const char *string, 	/* UTF-7 encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors,		/* error handling */
-    Py_ssize_t *consumed	/* bytes consumed */
+    const char *string,         /* UTF-7 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    Py_ssize_t *consumed        /* bytes consumed */
     );
 
 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 */
+    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 */
     );
 
 /* --- UTF-8 Codecs ------------------------------------------------------- */
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8(
-    const char *string, 	/* UTF-8 encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors		/* error handling */
+    const char *string,         /* UTF-8 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8Stateful(
-    const char *string, 	/* UTF-8 encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors,		/* error handling */
-    Py_ssize_t *consumed	/* bytes consumed */
+    const char *string,         /* UTF-8 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    Py_ssize_t *consumed        /* bytes consumed */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String(
-    PyObject *unicode	 	/* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 
 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 */
+    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 ------------------------------------------------------ */
@@ -877,14 +877,14 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
    the corresponding Unicode object.
 
    errors (if non-NULL) defines the error handling. It defaults
-   to "strict". 
+   to "strict".
 
    If byteorder is non-NULL, the decoder starts decoding using the
    given byte order:
 
-	*byteorder == -1: little endian
-	*byteorder == 0:  native order
-	*byteorder == 1:  big endian
+    *byteorder == -1: little endian
+    *byteorder == 0:  native order
+    *byteorder == 1:  big endian
 
    In native mode, the first four bytes of the stream are checked for a
    BOM mark. If found, the BOM mark is analysed, the byte order
@@ -897,29 +897,29 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
 */
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32(
-    const char *string, 	/* UTF-32 encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors,		/* error handling */
-    int *byteorder		/* pointer to byteorder to use
-				   0=native;-1=LE,1=BE; updated on
-				   exit */
+    const char *string,         /* UTF-32 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder              /* pointer to byteorder to use
+                                   0=native;-1=LE,1=BE; updated on
+                                   exit */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32Stateful(
-    const char *string, 	/* UTF-32 encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors,		/* error handling */
-    int *byteorder,		/* pointer to byteorder to use
-				   0=native;-1=LE,1=BE; updated on
-				   exit */
-    Py_ssize_t *consumed	/* bytes consumed */
+    const char *string,         /* UTF-32 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder,             /* pointer to byteorder to use
+                                   0=native;-1=LE,1=BE; updated on
+                                   exit */
+    Py_ssize_t *consumed        /* bytes consumed */
     );
 
 /* Returns a Python string using the UTF-32 encoding in native byte
    order. The string always starts with a BOM mark.  */
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsUTF32String(
-    PyObject *unicode	 	/* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 
 /* Returns a Python string object holding the UTF-32 encoded value of
@@ -939,10 +939,10 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUTF32String(
 */
 
 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 */
+    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 */
     );
 
 /* --- UTF-16 Codecs ------------------------------------------------------ */
@@ -951,14 +951,14 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32(
    the corresponding Unicode object.
 
    errors (if non-NULL) defines the error handling. It defaults
-   to "strict". 
+   to "strict".
 
    If byteorder is non-NULL, the decoder starts decoding using the
    given byte order:
 
-	*byteorder == -1: little endian
-	*byteorder == 0:  native order
-	*byteorder == 1:  big endian
+    *byteorder == -1: little endian
+    *byteorder == 0:  native order
+    *byteorder == 1:  big endian
 
    In native mode, the first two bytes of the stream are checked for a
    BOM mark. If found, the BOM mark is analysed, the byte order
@@ -971,29 +971,29 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32(
 */
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16(
-    const char *string, 	/* UTF-16 encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors,		/* error handling */
-    int *byteorder		/* pointer to byteorder to use
-				   0=native;-1=LE,1=BE; updated on
-				   exit */
+    const char *string,         /* UTF-16 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder              /* pointer to byteorder to use
+                                   0=native;-1=LE,1=BE; updated on
+                                   exit */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16Stateful(
-    const char *string, 	/* UTF-16 encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors,		/* error handling */
-    int *byteorder,		/* pointer to byteorder to use
-				   0=native;-1=LE,1=BE; updated on
-				   exit */
-    Py_ssize_t *consumed	/* bytes consumed */
+    const char *string,         /* UTF-16 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder,             /* pointer to byteorder to use
+                                   0=native;-1=LE,1=BE; updated on
+                                   exit */
+    Py_ssize_t *consumed        /* bytes consumed */
     );
 
 /* Returns a Python string using the UTF-16 encoding in native byte
    order. The string always starts with a BOM mark.  */
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String(
-    PyObject *unicode	 	/* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 
 /* Returns a Python string object holding the UTF-16 encoded value of
@@ -1017,44 +1017,44 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String(
 */
 
 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 */
+    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 */
     );
 
 /* --- Unicode-Escape Codecs ---------------------------------------------- */
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape(
-    const char *string, 	/* Unicode-Escape encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors		/* error handling */
+    const char *string,         /* Unicode-Escape encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString(
-    PyObject *unicode	 	/* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(
-    const Py_UNICODE *data, 	/* Unicode char buffer */
-    Py_ssize_t length	 	/* Number of Py_UNICODE chars to encode */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length           /* Number of Py_UNICODE chars to encode */
     );
 
 /* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape(
-    const char *string, 	/* Raw-Unicode-Escape encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors		/* error handling */
+    const char *string,         /* Raw-Unicode-Escape encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString(
-    PyObject *unicode	 	/* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
-    const Py_UNICODE *data, 	/* Unicode char buffer */
-    Py_ssize_t length	 	/* Number of Py_UNICODE chars to encode */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length           /* Number of Py_UNICODE chars to encode */
     );
 
 /* --- Unicode Internal Codec ---------------------------------------------
@@ -1067,53 +1067,53 @@ PyObject *_PyUnicode_DecodeUnicodeInternal(
     const char *errors
     );
 
-/* --- Latin-1 Codecs ----------------------------------------------------- 
+/* --- Latin-1 Codecs -----------------------------------------------------
 
    Note: Latin-1 corresponds to the first 256 Unicode ordinals.
 
 */
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1(
-    const char *string, 	/* Latin-1 encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors		/* error handling */
+    const char *string,         /* Latin-1 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String(
-    PyObject *unicode	 	/* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 
 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 */
+    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 ------------------------------------------------------- 
+/* --- ASCII Codecs -------------------------------------------------------
 
    Only 7-bit ASCII data is excepted. All other codes generate errors.
 
 */
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeASCII(
-    const char *string, 	/* ASCII encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    const char *errors		/* error handling */
+    const char *string,         /* ASCII encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString(
-    PyObject *unicode	 	/* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 
 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 */
+    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 ----------------------------------------------- 
+/* --- Character Map Codecs -----------------------------------------------
 
-   This codec uses mappings to encode and decode characters. 
+   This codec uses mappings to encode and decode characters.
 
    Decoding mappings must map single string characters to single
    Unicode characters, integers (which are then interpreted as Unicode
@@ -1134,25 +1134,25 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
 */
 
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeCharmap(
-    const char *string, 	/* Encoded string */
-    Py_ssize_t length,	 	/* size of string */
-    PyObject *mapping,		/* character mapping 
-				   (char ordinal -> unicode ordinal) */
-    const char *errors		/* error handling */
+    const char *string,         /* Encoded string */
+    Py_ssize_t length,          /* size of string */
+    PyObject *mapping,          /* character mapping
+                                   (char ordinal -> unicode ordinal) */
+    const char *errors          /* error handling */
     );
 
 PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString(
-    PyObject *unicode,	 	/* Unicode object */
-    PyObject *mapping		/* character mapping 
-				   (unicode ordinal -> char ordinal) */
+    PyObject *unicode,          /* Unicode object */
+    PyObject *mapping           /* character mapping
+                                   (unicode ordinal -> char ordinal) */
     );
 
 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,		/* character mapping 
-				   (unicode ordinal -> char ordinal) */
-    const char *errors		/* error handling */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    PyObject *mapping,          /* character mapping
+                                   (unicode ordinal -> char ordinal) */
+    const char *errors          /* error handling */
     );
 
 /* Translate a Py_UNICODE buffer of the given length by applying a
@@ -1160,7 +1160,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
    object.
 
    The mapping table must map Unicode ordinal integers to Unicode
-   ordinal integers or None (causing deletion of the character). 
+   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
@@ -1169,10 +1169,10 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
 */
 
 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 */
+    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 */
     );
 
 #ifdef MS_WIN32
@@ -1221,7 +1221,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
 
       NULL or "strict": raise a ValueError
       "ignore": ignore the wrong characters (these are not copied to the
-		output buffer)
+                output buffer)
       "replace": replaces illegal characters with '?'
 
    Returns 0 on success, -1 on failure.
@@ -1229,10 +1229,10 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
 */
 
 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 */
+    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 */
     );
 
 /* --- File system encoding ---------------------------------------------- */
@@ -1271,24 +1271,24 @@ PyAPI_FUNC(PyObject*) PyUnicode_DecodeFSDefaultAndSize(
 /* Concat two strings giving a new Unicode string. */
 
 PyAPI_FUNC(PyObject*) PyUnicode_Concat(
-    PyObject *left,	 	/* Left string */
-    PyObject *right	 	/* Right string */
+    PyObject *left,             /* Left string */
+    PyObject *right             /* Right string */
     );
 
 /* Concat two strings and put the result in *pleft
    (sets *pleft to NULL on error) */
 
 PyAPI_FUNC(void) PyUnicode_Append(
-    PyObject **pleft,	 	/* Pointer to left string */
-    PyObject *right	 	/* Right string */
+    PyObject **pleft,           /* Pointer to left string */
+    PyObject *right             /* Right string */
     );
 
 /* Concat two strings, put the result in *pleft and drop the right object
    (sets *pleft to NULL on error) */
 
 PyAPI_FUNC(void) PyUnicode_AppendAndDel(
-    PyObject **pleft,	 	/* Pointer to left string */
-    PyObject *right	 	/* Right string */
+    PyObject **pleft,           /* Pointer to left string */
+    PyObject *right             /* Right string */
     );
 
 /* Split a string giving a list of Unicode strings.
@@ -1303,35 +1303,35 @@ PyAPI_FUNC(void) PyUnicode_AppendAndDel(
 */
 
 PyAPI_FUNC(PyObject*) PyUnicode_Split(
-    PyObject *s,		/* String to split */
-    PyObject *sep,		/* String separator */
-    Py_ssize_t maxsplit		/* Maxsplit count */
-    );		
+    PyObject *s,                /* String to split */
+    PyObject *sep,              /* String separator */
+    Py_ssize_t maxsplit         /* Maxsplit count */
+    );
 
 /* Dito, but split at line breaks.
 
    CRLF is considered to be one line break. Line breaks are not
    included in the resulting list. */
-    
+
 PyAPI_FUNC(PyObject*) PyUnicode_Splitlines(
-    PyObject *s,		/* String to split */
-    int keepends		/* If true, line end markers are included */
-    );		
+    PyObject *s,                /* String to split */
+    int keepends                /* If true, line end markers are included */
+    );
 
 /* Partition a string using a given separator. */
 
 PyAPI_FUNC(PyObject*) PyUnicode_Partition(
-    PyObject *s,		/* String to partition */
-    PyObject *sep		/* String separator */
-    );		
+    PyObject *s,                /* String to partition */
+    PyObject *sep               /* String separator */
+    );
 
 /* Partition a string using a given separator, searching from the end of the
    string. */
 
 PyAPI_FUNC(PyObject*) PyUnicode_RPartition(
-    PyObject *s,		/* String to partition */
-    PyObject *sep		/* String separator */
-    );		
+    PyObject *s,                /* String to partition */
+    PyObject *sep               /* String separator */
+    );
 
 /* Split a string giving a list of Unicode strings.
 
@@ -1347,16 +1347,16 @@ PyAPI_FUNC(PyObject*) PyUnicode_RPartition(
 */
 
 PyAPI_FUNC(PyObject*) PyUnicode_RSplit(
-    PyObject *s,		/* String to split */
-    PyObject *sep,		/* String separator */
-    Py_ssize_t maxsplit		/* Maxsplit count */
-    );		
+    PyObject *s,                /* String to split */
+    PyObject *sep,              /* String separator */
+    Py_ssize_t maxsplit         /* Maxsplit count */
+    );
 
 /* Translate a string by applying a character mapping table to it and
    return the resulting Unicode object.
 
    The mapping table must map Unicode ordinal integers to Unicode
-   ordinal integers or None (causing deletion of the character). 
+   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
@@ -1365,28 +1365,28 @@ PyAPI_FUNC(PyObject*) PyUnicode_RSplit(
 */
 
 PyAPI_FUNC(PyObject *) PyUnicode_Translate(
-    PyObject *str,		/* String */ 
-    PyObject *table,		/* Translate table */
-    const char *errors		/* error handling */
+    PyObject *str,              /* String */
+    PyObject *table,            /* Translate table */
+    const char *errors          /* error handling */
     );
 
 /* Join a sequence of strings using the given separator and return
    the resulting Unicode string. */
-    
+
 PyAPI_FUNC(PyObject*) PyUnicode_Join(
-    PyObject *separator, 	/* Separator string */
-    PyObject *seq	 	/* Sequence object */
+    PyObject *separator,        /* Separator string */
+    PyObject *seq               /* Sequence object */
     );
 
 /* Return 1 if substr matches str[start:end] at the given tail end, 0
    otherwise. */
 
 PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch(
-    PyObject *str,		/* String */ 
-    PyObject *substr,		/* Prefix or Suffix string */
-    Py_ssize_t start,		/* Start index */
-    Py_ssize_t end,		/* Stop index */
-    int direction		/* Tail end: -1 prefix, +1 suffix */
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Prefix or Suffix string */
+    Py_ssize_t start,           /* Start index */
+    Py_ssize_t end,             /* Stop index */
+    int direction               /* Tail end: -1 prefix, +1 suffix */
     );
 
 /* Return the first position of substr in str[start:end] using the
@@ -1394,39 +1394,39 @@ PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch(
    an error occurred and an exception is set. */
 
 PyAPI_FUNC(Py_ssize_t) PyUnicode_Find(
-    PyObject *str,		/* String */ 
-    PyObject *substr,		/* Substring to find */
-    Py_ssize_t start,		/* Start index */
-    Py_ssize_t end,		/* Stop index */
-    int direction		/* Find direction: +1 forward, -1 backward */
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Substring to find */
+    Py_ssize_t start,           /* Start index */
+    Py_ssize_t end,             /* Stop index */
+    int direction               /* Find direction: +1 forward, -1 backward */
     );
 
 /* Count the number of occurrences of substr in str[start:end]. */
 
 PyAPI_FUNC(Py_ssize_t) PyUnicode_Count(
-    PyObject *str,		/* String */ 
-    PyObject *substr,		/* Substring to count */
-    Py_ssize_t start,		/* Start index */
-    Py_ssize_t end		/* Stop index */
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Substring to count */
+    Py_ssize_t start,           /* Start index */
+    Py_ssize_t end              /* Stop index */
     );
 
 /* Replace at most maxcount occurrences of substr in str with replstr
    and return the resulting Unicode object. */
 
 PyAPI_FUNC(PyObject *) PyUnicode_Replace(
-    PyObject *str,		/* String */ 
-    PyObject *substr,		/* Substring to find */
-    PyObject *replstr,		/* Substring to replace */
-    Py_ssize_t maxcount		/* Max. number of replacements to apply;
-				   -1 = all */
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Substring to find */
+    PyObject *replstr,          /* Substring to replace */
+    Py_ssize_t maxcount         /* Max. number of replacements to apply;
+                                   -1 = all */
     );
 
 /* Compare two strings and return -1, 0, 1 for less than, equal,
    greater than resp. */
 
 PyAPI_FUNC(int) PyUnicode_Compare(
-    PyObject *left,		/* Left string */ 
-    PyObject *right		/* Right string */
+    PyObject *left,             /* Left string */
+    PyObject *right             /* Right string */
     );
 
 PyAPI_FUNC(int) PyUnicode_CompareWithASCIIString(
@@ -1451,17 +1451,17 @@ PyAPI_FUNC(int) PyUnicode_CompareWithASCIIString(
 */
 
 PyAPI_FUNC(PyObject *) PyUnicode_RichCompare(
-    PyObject *left,		/* Left string */ 
-    PyObject *right,		/* Right string */
-    int op			/* Operation: Py_EQ, Py_NE, Py_GT, etc. */
+    PyObject *left,             /* Left string */
+    PyObject *right,            /* Right string */
+    int op                      /* Operation: Py_EQ, Py_NE, Py_GT, etc. */
     );
 
 /* Apply a argument tuple or dictionary to a format string and return
    the resulting Unicode string. */
 
 PyAPI_FUNC(PyObject *) PyUnicode_Format(
-    PyObject *format,		/* Format string */ 
-    PyObject *args		/* Argument tuple or dictionary */
+    PyObject *format,           /* Format string */
+    PyObject *args              /* Argument tuple or dictionary */
     );
 
 /* Checks whether element is contained in container and return 1/0
@@ -1471,8 +1471,8 @@ PyAPI_FUNC(PyObject *) PyUnicode_Format(
    returned in case of an error. */
 
 PyAPI_FUNC(int) PyUnicode_Contains(
-    PyObject *container,	/* Container string */ 
-    PyObject *element		/* Element string */
+    PyObject *container,        /* Container string */
+    PyObject *element           /* Element string */
     );
 
 /* Checks whether argument is a valid identifier. */
@@ -1513,82 +1513,82 @@ PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping(Py_UNICODE *buffer,
 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. 
+   Py_UNICODE_TO* macros instead.
 
    These APIs are implemented in Objects/unicodectype.c.
 
 */
 
 PyAPI_FUNC(int) _PyUnicode_IsLowercase(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsUppercase(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsTitlecase(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsXidStart(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsXidContinue(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsWhitespace(
-    const Py_UNICODE ch 	/* Unicode character */
+    const Py_UNICODE ch         /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsLinebreak(
-    const Py_UNICODE ch 	/* Unicode character */
+    const Py_UNICODE ch         /* Unicode character */
     );
 
 PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToLowercase(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToUppercase(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToTitlecase(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_ToDigit(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(double) _PyUnicode_ToNumeric(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsDigit(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsNumeric(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsPrintable(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(int) _PyUnicode_IsAlpha(
-    Py_UNICODE ch 	/* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 
 PyAPI_FUNC(size_t) Py_UNICODE_strlen(const Py_UNICODE *u);