diff --git a/Python/codecs.c b/Python/codecs.c
index 3849cf9..57bd0f4 100644
--- a/Python/codecs.c
+++ b/Python/codecs.c
@@ -14,7 +14,7 @@
 /* --- Codec Registry ----------------------------------------------------- */
 
 /* Import the standard encodings package which will register the first
-   codec search function. 
+   codec search function.
 
    This is done in a lazy way so that the Unicode implementation does
    not downgrade startup time of scripts not needing it.
@@ -30,14 +30,14 @@
 {
     PyInterpreterState *interp = PyThreadState_GET()->interp;
     if (interp->codec_search_path == NULL && _PyCodecRegistry_Init())
-	goto onError;
+        goto onError;
     if (search_function == NULL) {
-	PyErr_BadArgument();
-	goto onError;
+        PyErr_BadArgument();
+        goto onError;
     }
     if (!PyCallable_Check(search_function)) {
-	PyErr_SetString(PyExc_TypeError, "argument must be callable");
-	goto onError;
+        PyErr_SetString(PyExc_TypeError, "argument must be callable");
+        goto onError;
     }
     return PyList_Append(interp->codec_search_path, search_function);
 
@@ -55,15 +55,15 @@
     size_t len = strlen(string);
     char *p;
     PyObject *v;
-    
+
     if (len > PY_SSIZE_T_MAX) {
-	PyErr_SetString(PyExc_OverflowError, "string is too large");
-	return NULL;
+        PyErr_SetString(PyExc_OverflowError, "string is too large");
+        return NULL;
     }
-	
+
     v = PyString_FromStringAndSize(NULL, len);
     if (v == NULL)
-	return NULL;
+        return NULL;
     p = PyString_AS_STRING(v);
     for (i = 0; i < len; i++) {
         register char ch = string[i];
@@ -71,7 +71,7 @@
             ch = '-';
         else
             ch = tolower(Py_CHARMASK(ch));
-	p[i] = ch;
+        p[i] = ch;
     }
     return v;
 }
@@ -83,7 +83,7 @@
    characters. This makes encodings looked up through this mechanism
    effectively case-insensitive.
 
-   If no codec is found, a LookupError is set and NULL returned. 
+   If no codec is found, a LookupError is set and NULL returned.
 
    As side effect, this tries to load the encodings package, if not
    yet done. This is part of the lazy load strategy for the encodings
@@ -98,72 +98,72 @@
     Py_ssize_t i, len;
 
     if (encoding == NULL) {
-	PyErr_BadArgument();
-	goto onError;
+        PyErr_BadArgument();
+        goto onError;
     }
 
     interp = PyThreadState_GET()->interp;
     if (interp->codec_search_path == NULL && _PyCodecRegistry_Init())
-	goto onError;
+        goto onError;
 
     /* Convert the encoding to a normalized Python string: all
        characters are converted to lower case, spaces and hyphens are
        replaced with underscores. */
     v = normalizestring(encoding);
     if (v == NULL)
-	goto onError;
+        goto onError;
     PyString_InternInPlace(&v);
 
     /* First, try to lookup the name in the registry dictionary */
     result = PyDict_GetItem(interp->codec_search_cache, v);
     if (result != NULL) {
-	Py_INCREF(result);
-	Py_DECREF(v);
-	return result;
+        Py_INCREF(result);
+        Py_DECREF(v);
+        return result;
     }
-    
+
     /* Next, scan the search functions in order of registration */
     args = PyTuple_New(1);
     if (args == NULL)
-	goto onError;
+        goto onError;
     PyTuple_SET_ITEM(args,0,v);
 
     len = PyList_Size(interp->codec_search_path);
     if (len < 0)
-	goto onError;
+        goto onError;
     if (len == 0) {
-	PyErr_SetString(PyExc_LookupError,
-			"no codec search functions registered: "
-			"can't find encoding");
-	goto onError;
+        PyErr_SetString(PyExc_LookupError,
+                        "no codec search functions registered: "
+                        "can't find encoding");
+        goto onError;
     }
 
     for (i = 0; i < len; i++) {
-	PyObject *func;
-	
-	func = PyList_GetItem(interp->codec_search_path, i);
-	if (func == NULL)
-	    goto onError;
-	result = PyEval_CallObject(func, args);
-	if (result == NULL)
-	    goto onError;
-	if (result == Py_None) {
-	    Py_DECREF(result);
-	    continue;
-	}
-	if (!PyTuple_Check(result) || PyTuple_GET_SIZE(result) != 4) {
-	    PyErr_SetString(PyExc_TypeError,
-			    "codec search functions must return 4-tuples");
-	    Py_DECREF(result);
-	    goto onError;
-	}
-	break;
+        PyObject *func;
+
+        func = PyList_GetItem(interp->codec_search_path, i);
+        if (func == NULL)
+            goto onError;
+        result = PyEval_CallObject(func, args);
+        if (result == NULL)
+            goto onError;
+        if (result == Py_None) {
+            Py_DECREF(result);
+            continue;
+        }
+        if (!PyTuple_Check(result) || PyTuple_GET_SIZE(result) != 4) {
+            PyErr_SetString(PyExc_TypeError,
+                            "codec search functions must return 4-tuples");
+            Py_DECREF(result);
+            goto onError;
+        }
+        break;
     }
     if (i == len) {
-	/* XXX Perhaps we should cache misses too ? */
-	PyErr_Format(PyExc_LookupError,
+        /* XXX Perhaps we should cache misses too ? */
+        PyErr_Format(PyExc_LookupError,
                      "unknown encoding: %s", encoding);
-	goto onError;
+        goto onError;
     }
 
     /* Cache and return the result */
@@ -178,24 +178,24 @@
 
 static
 PyObject *args_tuple(PyObject *object,
-		     const char *errors)
+                     const char *errors)
 {
     PyObject *args;
-    
+
     args = PyTuple_New(1 + (errors != NULL));
     if (args == NULL)
-	return NULL;
+        return NULL;
     Py_INCREF(object);
     PyTuple_SET_ITEM(args,0,object);
     if (errors) {
-	PyObject *v;
-	
-	v = PyString_FromString(errors);
-	if (v == NULL) {
-	    Py_DECREF(args);
-	    return NULL;
-	}
-	PyTuple_SET_ITEM(args, 1, v);
+        PyObject *v;
+
+        v = PyString_FromString(errors);
+        if (v == NULL) {
+            Py_DECREF(args);
+            return NULL;
+        }
+        PyTuple_SET_ITEM(args, 1, v);
     }
     return args;
 }
@@ -210,7 +210,7 @@
 
     codecs = _PyCodec_Lookup(encoding);
     if (codecs == NULL)
-	return NULL;
+        return NULL;
     v = PyTuple_GET_ITEM(codecs, index);
     Py_DECREF(codecs);
     Py_INCREF(v);
@@ -221,22 +221,22 @@
 
 static
 PyObject *codec_getincrementalcodec(const char *encoding,
-				    const char *errors,
-				    const char *attrname)
+                                    const char *errors,
+                                    const char *attrname)
 {
     PyObject *codecs, *ret, *inccodec;
 
     codecs = _PyCodec_Lookup(encoding);
     if (codecs == NULL)
-	return NULL;
+        return NULL;
     inccodec = PyObject_GetAttrString(codecs, attrname);
     Py_DECREF(codecs);
     if (inccodec == NULL)
-	return NULL;
+        return NULL;
     if (errors)
-	ret = PyObject_CallFunction(inccodec, "s", errors);
+        ret = PyObject_CallFunction(inccodec, "s", errors);
     else
-	ret = PyObject_CallFunction(inccodec, NULL);
+        ret = PyObject_CallFunction(inccodec, NULL);
     Py_DECREF(inccodec);
     return ret;
 }
@@ -245,29 +245,29 @@
 
 static
 PyObject *codec_getstreamcodec(const char *encoding,
-			       PyObject *stream,
-			       const char *errors,
-			       const int index)
+                               PyObject *stream,
+                               const char *errors,
+                               const int index)
 {
     PyObject *codecs, *streamcodec, *codeccls;
 
     codecs = _PyCodec_Lookup(encoding);
     if (codecs == NULL)
-	return NULL;
+        return NULL;
 
     codeccls = PyTuple_GET_ITEM(codecs, index);
     if (errors != NULL)
-	streamcodec = PyObject_CallFunction(codeccls, "Os", stream, errors);
+        streamcodec = PyObject_CallFunction(codeccls, "Os", stream, errors);
     else
-	streamcodec = PyObject_CallFunction(codeccls, "O", stream);
+        streamcodec = PyObject_CallFunction(codeccls, "O", stream);
     Py_DECREF(codecs);
     return streamcodec;
 }
 
-/* Convenience APIs to query the Codec registry. 
-   
+/* Convenience APIs to query the Codec registry.
+
    All APIs return a codec object with incremented refcount.
-   
+
  */
 
 PyObject *PyCodec_Encoder(const char *encoding)
@@ -281,27 +281,27 @@
 }
 
 PyObject *PyCodec_IncrementalEncoder(const char *encoding,
-				     const char *errors)
+                                     const char *errors)
 {
     return codec_getincrementalcodec(encoding, errors, "incrementalencoder");
 }
 
 PyObject *PyCodec_IncrementalDecoder(const char *encoding,
-				     const char *errors)
+                                     const char *errors)
 {
     return codec_getincrementalcodec(encoding, errors, "incrementaldecoder");
 }
 
 PyObject *PyCodec_StreamReader(const char *encoding,
-			       PyObject *stream,
-			       const char *errors)
+                               PyObject *stream,
+                               const char *errors)
 {
     return codec_getstreamcodec(encoding, stream, errors, 2);
 }
 
 PyObject *PyCodec_StreamWriter(const char *encoding,
-			       PyObject *stream,
-			       const char *errors)
+                               PyObject *stream,
+                               const char *errors)
 {
     return codec_getstreamcodec(encoding, stream, errors, 3);
 }
@@ -312,8 +312,8 @@
    errors is passed to the encoder factory as argument if non-NULL. */
 
 PyObject *PyCodec_Encode(PyObject *object,
-			 const char *encoding,
-			 const char *errors)
+                         const char *encoding,
+                         const char *errors)
 {
     PyObject *encoder = NULL;
     PyObject *args = NULL, *result = NULL;
@@ -321,21 +321,21 @@
 
     encoder = PyCodec_Encoder(encoding);
     if (encoder == NULL)
-	goto onError;
+        goto onError;
 
     args = args_tuple(object, errors);
     if (args == NULL)
-	goto onError;
-    
+        goto onError;
+
     result = PyEval_CallObject(encoder,args);
     if (result == NULL)
-	goto onError;
+        goto onError;
 
-    if (!PyTuple_Check(result) || 
-	PyTuple_GET_SIZE(result) != 2) {
-	PyErr_SetString(PyExc_TypeError,
-			"encoder must return a tuple (object,integer)");
-	goto onError;
+    if (!PyTuple_Check(result) ||
+        PyTuple_GET_SIZE(result) != 2) {
+        PyErr_SetString(PyExc_TypeError,
+                        "encoder must return a tuple (object,integer)");
+        goto onError;
     }
     v = PyTuple_GET_ITEM(result,0);
     Py_INCREF(v);
@@ -345,7 +345,7 @@
     Py_DECREF(encoder);
     Py_DECREF(result);
     return v;
-	
+
  onError:
     Py_XDECREF(result);
     Py_XDECREF(args);
@@ -359,8 +359,8 @@
    errors is passed to the decoder factory as argument if non-NULL. */
 
 PyObject *PyCodec_Decode(PyObject *object,
-			 const char *encoding,
-			 const char *errors)
+                         const char *encoding,
+                         const char *errors)
 {
     PyObject *decoder = NULL;
     PyObject *args = NULL, *result = NULL;
@@ -368,20 +368,20 @@
 
     decoder = PyCodec_Decoder(encoding);
     if (decoder == NULL)
-	goto onError;
+        goto onError;
 
     args = args_tuple(object, errors);
     if (args == NULL)
-	goto onError;
-    
+        goto onError;
+
     result = PyEval_CallObject(decoder,args);
     if (result == NULL)
-	goto onError;
-    if (!PyTuple_Check(result) || 
-	PyTuple_GET_SIZE(result) != 2) {
-	PyErr_SetString(PyExc_TypeError,
-			"decoder must return a tuple (object,integer)");
-	goto onError;
+        goto onError;
+    if (!PyTuple_Check(result) ||
+        PyTuple_GET_SIZE(result) != 2) {
+        PyErr_SetString(PyExc_TypeError,
+                        "decoder must return a tuple (object,integer)");
+        goto onError;
     }
     v = PyTuple_GET_ITEM(result,0);
     Py_INCREF(v);
@@ -391,7 +391,7 @@
     Py_DECREF(decoder);
     Py_DECREF(result);
     return v;
-	
+
  onError:
     Py_XDECREF(args);
     Py_XDECREF(decoder);
@@ -409,13 +409,13 @@
 {
     PyInterpreterState *interp = PyThreadState_GET()->interp;
     if (interp->codec_search_path == NULL && _PyCodecRegistry_Init())
-	return -1;
+        return -1;
     if (!PyCallable_Check(error)) {
-	PyErr_SetString(PyExc_TypeError, "handler must be callable");
-	return -1;
+        PyErr_SetString(PyExc_TypeError, "handler must be callable");
+        return -1;
     }
     return PyDict_SetItemString(interp->codec_error_registry,
-	    			(char *)name, error);
+                                (char *)name, error);
 }
 
 /* Lookup the error handling callback function registered under the
@@ -427,15 +427,15 @@
 
     PyInterpreterState *interp = PyThreadState_GET()->interp;
     if (interp->codec_search_path == NULL && _PyCodecRegistry_Init())
-	return NULL;
+        return NULL;
 
     if (name==NULL)
-	name = "strict";
+        name = "strict";
     handler = PyDict_GetItemString(interp->codec_error_registry, (char *)name);
     if (!handler)
-	PyErr_Format(PyExc_LookupError, "unknown error handler name '%.400s'", name);
+        PyErr_Format(PyExc_LookupError, "unknown error handler name '%.400s'", name);
     else
-	Py_INCREF(handler);
+        Py_INCREF(handler);
     return handler;
 }
 
@@ -443,18 +443,18 @@
 {
     PyObject *type = PyObject_GetAttrString(exc, "__class__");
     if (type != NULL) {
-	PyObject *name = PyObject_GetAttrString(type, "__name__");
-	Py_DECREF(type);
-	if (name != NULL) {
-	    PyObject *string = PyObject_Str(name);
-	    Py_DECREF(name);
-	    if (string != NULL) {
-	        PyErr_Format(PyExc_TypeError,
-		    "don't know how to handle %.400s in error callback",
-		    PyString_AS_STRING(string));
-	        Py_DECREF(string);
-	    }
-	}
+        PyObject *name = PyObject_GetAttrString(type, "__name__");
+        Py_DECREF(type);
+        if (name != NULL) {
+            PyObject *string = PyObject_Str(name);
+            Py_DECREF(name);
+            if (string != NULL) {
+                PyErr_Format(PyExc_TypeError,
+                    "don't know how to handle %.400s in error callback",
+                    PyString_AS_STRING(string));
+                Py_DECREF(string);
+            }
+        }
     }
 }
 
@@ -463,7 +463,7 @@
     if (PyExceptionInstance_Check(exc))
         PyErr_SetObject(PyExceptionInstance_Class(exc), exc);
     else
-	PyErr_SetString(PyExc_TypeError, "codec must pass exception instance");
+        PyErr_SetString(PyExc_TypeError, "codec must pass exception instance");
     return NULL;
 }
 
@@ -473,20 +473,20 @@
 {
     Py_ssize_t end;
     if (PyObject_IsInstance(exc, PyExc_UnicodeEncodeError)) {
-	if (PyUnicodeEncodeError_GetEnd(exc, &end))
-	    return NULL;
+        if (PyUnicodeEncodeError_GetEnd(exc, &end))
+            return NULL;
     }
     else if (PyObject_IsInstance(exc, PyExc_UnicodeDecodeError)) {
-	if (PyUnicodeDecodeError_GetEnd(exc, &end))
-	    return NULL;
+        if (PyUnicodeDecodeError_GetEnd(exc, &end))
+            return NULL;
     }
     else if (PyObject_IsInstance(exc, PyExc_UnicodeTranslateError)) {
-	if (PyUnicodeTranslateError_GetEnd(exc, &end))
-	    return NULL;
+        if (PyUnicodeTranslateError_GetEnd(exc, &end))
+            return NULL;
     }
     else {
-	wrong_exception_type(exc);
-	return NULL;
+        wrong_exception_type(exc);
+        return NULL;
     }
     /* ouch: passing NULL, 0, pos gives None instead of u'' */
     return Py_BuildValue("(u#n)", &end, 0, end);
@@ -501,155 +501,155 @@
     Py_ssize_t i;
 
     if (PyObject_IsInstance(exc, PyExc_UnicodeEncodeError)) {
-	PyObject *res;
-	Py_UNICODE *p;
-	if (PyUnicodeEncodeError_GetStart(exc, &start))
-	    return NULL;
-	if (PyUnicodeEncodeError_GetEnd(exc, &end))
-	    return NULL;
-	res = PyUnicode_FromUnicode(NULL, end-start);
-	if (res == NULL)
-	    return NULL;
-	for (p = PyUnicode_AS_UNICODE(res), i = start;
-	    i<end; ++p, ++i)
-	    *p = '?';
-	restuple = Py_BuildValue("(On)", res, end);
-	Py_DECREF(res);
-	return restuple;
+        PyObject *res;
+        Py_UNICODE *p;
+        if (PyUnicodeEncodeError_GetStart(exc, &start))
+            return NULL;
+        if (PyUnicodeEncodeError_GetEnd(exc, &end))
+            return NULL;
+        res = PyUnicode_FromUnicode(NULL, end-start);
+        if (res == NULL)
+            return NULL;
+        for (p = PyUnicode_AS_UNICODE(res), i = start;
+            i<end; ++p, ++i)
+            *p = '?';
+        restuple = Py_BuildValue("(On)", res, end);
+        Py_DECREF(res);
+        return restuple;
     }
     else if (PyObject_IsInstance(exc, PyExc_UnicodeDecodeError)) {
-	Py_UNICODE res = Py_UNICODE_REPLACEMENT_CHARACTER;
-	if (PyUnicodeDecodeError_GetEnd(exc, &end))
-	    return NULL;
-	return Py_BuildValue("(u#n)", &res, 1, end);
+        Py_UNICODE res = Py_UNICODE_REPLACEMENT_CHARACTER;
+        if (PyUnicodeDecodeError_GetEnd(exc, &end))
+            return NULL;
+        return Py_BuildValue("(u#n)", &res, 1, end);
     }
     else if (PyObject_IsInstance(exc, PyExc_UnicodeTranslateError)) {
-	PyObject *res;
-	Py_UNICODE *p;
-	if (PyUnicodeTranslateError_GetStart(exc, &start))
-	    return NULL;
-	if (PyUnicodeTranslateError_GetEnd(exc, &end))
-	    return NULL;
-	res = PyUnicode_FromUnicode(NULL, end-start);
-	if (res == NULL)
-	    return NULL;
-	for (p = PyUnicode_AS_UNICODE(res), i = start;
-	    i<end; ++p, ++i)
-	    *p = Py_UNICODE_REPLACEMENT_CHARACTER;
-	restuple = Py_BuildValue("(On)", res, end);
-	Py_DECREF(res);
-	return restuple;
+        PyObject *res;
+        Py_UNICODE *p;
+        if (PyUnicodeTranslateError_GetStart(exc, &start))
+            return NULL;
+        if (PyUnicodeTranslateError_GetEnd(exc, &end))
+            return NULL;
+        res = PyUnicode_FromUnicode(NULL, end-start);
+        if (res == NULL)
+            return NULL;
+        for (p = PyUnicode_AS_UNICODE(res), i = start;
+            i<end; ++p, ++i)
+            *p = Py_UNICODE_REPLACEMENT_CHARACTER;
+        restuple = Py_BuildValue("(On)", res, end);
+        Py_DECREF(res);
+        return restuple;
     }
     else {
-	wrong_exception_type(exc);
-	return NULL;
+        wrong_exception_type(exc);
+        return NULL;
     }
 }
 
 PyObject *PyCodec_XMLCharRefReplaceErrors(PyObject *exc)
 {
     if (PyObject_IsInstance(exc, PyExc_UnicodeEncodeError)) {
-	PyObject *restuple;
-	PyObject *object;
-	Py_ssize_t start;
-	Py_ssize_t end;
-	PyObject *res;
-	Py_UNICODE *p;
-	Py_UNICODE *startp;
-	Py_UNICODE *outp;
-	int ressize;
-	if (PyUnicodeEncodeError_GetStart(exc, &start))
-	    return NULL;
-	if (PyUnicodeEncodeError_GetEnd(exc, &end))
-	    return NULL;
-	if (!(object = PyUnicodeEncodeError_GetObject(exc)))
-	    return NULL;
-	startp = PyUnicode_AS_UNICODE(object);
-	for (p = startp+start, ressize = 0; p < startp+end; ++p) {
-	    if (*p<10)
-		ressize += 2+1+1;
-	    else if (*p<100)
-		ressize += 2+2+1;
-	    else if (*p<1000)
-		ressize += 2+3+1;
-	    else if (*p<10000)
-		ressize += 2+4+1;
+        PyObject *restuple;
+        PyObject *object;
+        Py_ssize_t start;
+        Py_ssize_t end;
+        PyObject *res;
+        Py_UNICODE *p;
+        Py_UNICODE *startp;
+        Py_UNICODE *outp;
+        int ressize;
+        if (PyUnicodeEncodeError_GetStart(exc, &start))
+            return NULL;
+        if (PyUnicodeEncodeError_GetEnd(exc, &end))
+            return NULL;
+        if (!(object = PyUnicodeEncodeError_GetObject(exc)))
+            return NULL;
+        startp = PyUnicode_AS_UNICODE(object);
+        for (p = startp+start, ressize = 0; p < startp+end; ++p) {
+            if (*p<10)
+                ressize += 2+1+1;
+            else if (*p<100)
+                ressize += 2+2+1;
+            else if (*p<1000)
+                ressize += 2+3+1;
+            else if (*p<10000)
+                ressize += 2+4+1;
 #ifndef Py_UNICODE_WIDE
-	    else
-		ressize += 2+5+1;
+            else
+                ressize += 2+5+1;
 #else
-	    else if (*p<100000)
-		ressize += 2+5+1;
-	    else if (*p<1000000)
-		ressize += 2+6+1;
-	    else
-		ressize += 2+7+1;
+            else if (*p<100000)
+                ressize += 2+5+1;
+            else if (*p<1000000)
+                ressize += 2+6+1;
+            else
+                ressize += 2+7+1;
 #endif
-	}
-	/* allocate replacement */
-	res = PyUnicode_FromUnicode(NULL, ressize);
-	if (res == NULL) {
-	    Py_DECREF(object);
-	    return NULL;
-	}
-	/* generate replacement */
-	for (p = startp+start, outp = PyUnicode_AS_UNICODE(res);
-	    p < startp+end; ++p) {
-	    Py_UNICODE c = *p;
-	    int digits;
-	    int base;
-	    *outp++ = '&';
-	    *outp++ = '#';
-	    if (*p<10) {
-		digits = 1;
-		base = 1;
-	    }
-	    else if (*p<100) {
-		digits = 2;
-		base = 10;
-	    }
-	    else if (*p<1000) {
-		digits = 3;
-		base = 100;
-	    }
-	    else if (*p<10000) {
-		digits = 4;
-		base = 1000;
-	    }
+        }
+        /* allocate replacement */
+        res = PyUnicode_FromUnicode(NULL, ressize);
+        if (res == NULL) {
+            Py_DECREF(object);
+            return NULL;
+        }
+        /* generate replacement */
+        for (p = startp+start, outp = PyUnicode_AS_UNICODE(res);
+            p < startp+end; ++p) {
+            Py_UNICODE c = *p;
+            int digits;
+            int base;
+            *outp++ = '&';
+            *outp++ = '#';
+            if (*p<10) {
+                digits = 1;
+                base = 1;
+            }
+            else if (*p<100) {
+                digits = 2;
+                base = 10;
+            }
+            else if (*p<1000) {
+                digits = 3;
+                base = 100;
+            }
+            else if (*p<10000) {
+                digits = 4;
+                base = 1000;
+            }
 #ifndef Py_UNICODE_WIDE
-	    else {
-		digits = 5;
-		base = 10000;
-	    }
+            else {
+                digits = 5;
+                base = 10000;
+            }
 #else
-	    else if (*p<100000) {
-		digits = 5;
-		base = 10000;
-	    }
-	    else if (*p<1000000) {
-		digits = 6;
-		base = 100000;
-	    }
-	    else {
-		digits = 7;
-		base = 1000000;
-	    }
+            else if (*p<100000) {
+                digits = 5;
+                base = 10000;
+            }
+            else if (*p<1000000) {
+                digits = 6;
+                base = 100000;
+            }
+            else {
+                digits = 7;
+                base = 1000000;
+            }
 #endif
-	    while (digits-->0) {
-		*outp++ = '0' + c/base;
-		c %= base;
-		base /= 10;
-	    }
-	    *outp++ = ';';
-	}
-	restuple = Py_BuildValue("(On)", res, end);
-	Py_DECREF(res);
-	Py_DECREF(object);
-	return restuple;
+            while (digits-->0) {
+                *outp++ = '0' + c/base;
+                c %= base;
+                base /= 10;
+            }
+            *outp++ = ';';
+        }
+        restuple = Py_BuildValue("(On)", res, end);
+        Py_DECREF(res);
+        Py_DECREF(object);
+        return restuple;
     }
     else {
-	wrong_exception_type(exc);
-	return NULL;
+        wrong_exception_type(exc);
+        return NULL;
     }
 }
 
@@ -661,72 +661,72 @@
 PyObject *PyCodec_BackslashReplaceErrors(PyObject *exc)
 {
     if (PyObject_IsInstance(exc, PyExc_UnicodeEncodeError)) {
-	PyObject *restuple;
-	PyObject *object;
-	Py_ssize_t start;
-	Py_ssize_t end;
-	PyObject *res;
-	Py_UNICODE *p;
-	Py_UNICODE *startp;
-	Py_UNICODE *outp;
-	int ressize;
-	if (PyUnicodeEncodeError_GetStart(exc, &start))
-	    return NULL;
-	if (PyUnicodeEncodeError_GetEnd(exc, &end))
-	    return NULL;
-	if (!(object = PyUnicodeEncodeError_GetObject(exc)))
-	    return NULL;
-	startp = PyUnicode_AS_UNICODE(object);
-	for (p = startp+start, ressize = 0; p < startp+end; ++p) {
+        PyObject *restuple;
+        PyObject *object;
+        Py_ssize_t start;
+        Py_ssize_t end;
+        PyObject *res;
+        Py_UNICODE *p;
+        Py_UNICODE *startp;
+        Py_UNICODE *outp;
+        int ressize;
+        if (PyUnicodeEncodeError_GetStart(exc, &start))
+            return NULL;
+        if (PyUnicodeEncodeError_GetEnd(exc, &end))
+            return NULL;
+        if (!(object = PyUnicodeEncodeError_GetObject(exc)))
+            return NULL;
+        startp = PyUnicode_AS_UNICODE(object);
+        for (p = startp+start, ressize = 0; p < startp+end; ++p) {
 #ifdef Py_UNICODE_WIDE
-	    if (*p >= 0x00010000)
-		ressize += 1+1+8;
-	    else
+            if (*p >= 0x00010000)
+                ressize += 1+1+8;
+            else
 #endif
-	    if (*p >= 0x100) {
-		ressize += 1+1+4;
-	    }
-	    else
-		ressize += 1+1+2;
-	}
-	res = PyUnicode_FromUnicode(NULL, ressize);
-	if (res==NULL)
-	    return NULL;
-	for (p = startp+start, outp = PyUnicode_AS_UNICODE(res);
-	    p < startp+end; ++p) {
-	    Py_UNICODE c = *p;
-	    *outp++ = '\\';
+            if (*p >= 0x100) {
+                ressize += 1+1+4;
+            }
+            else
+                ressize += 1+1+2;
+        }
+        res = PyUnicode_FromUnicode(NULL, ressize);
+        if (res==NULL)
+            return NULL;
+        for (p = startp+start, outp = PyUnicode_AS_UNICODE(res);
+            p < startp+end; ++p) {
+            Py_UNICODE c = *p;
+            *outp++ = '\\';
 #ifdef Py_UNICODE_WIDE
-	    if (c >= 0x00010000) {
-		*outp++ = 'U';
-		*outp++ = hexdigits[(c>>28)&0xf];
-		*outp++ = hexdigits[(c>>24)&0xf];
-		*outp++ = hexdigits[(c>>20)&0xf];
-		*outp++ = hexdigits[(c>>16)&0xf];
-		*outp++ = hexdigits[(c>>12)&0xf];
-		*outp++ = hexdigits[(c>>8)&0xf];
-	    }
-	    else
+            if (c >= 0x00010000) {
+                *outp++ = 'U';
+                *outp++ = hexdigits[(c>>28)&0xf];
+                *outp++ = hexdigits[(c>>24)&0xf];
+                *outp++ = hexdigits[(c>>20)&0xf];
+                *outp++ = hexdigits[(c>>16)&0xf];
+                *outp++ = hexdigits[(c>>12)&0xf];
+                *outp++ = hexdigits[(c>>8)&0xf];
+            }
+            else
 #endif
-	    if (c >= 0x100) {
-		*outp++ = 'u';
-		*outp++ = hexdigits[(c>>12)&0xf];
-		*outp++ = hexdigits[(c>>8)&0xf];
-	    }
-	    else
-		*outp++ = 'x';
-	    *outp++ = hexdigits[(c>>4)&0xf];
-	    *outp++ = hexdigits[c&0xf];
-	}
+            if (c >= 0x100) {
+                *outp++ = 'u';
+                *outp++ = hexdigits[(c>>12)&0xf];
+                *outp++ = hexdigits[(c>>8)&0xf];
+            }
+            else
+                *outp++ = 'x';
+            *outp++ = hexdigits[(c>>4)&0xf];
+            *outp++ = hexdigits[c&0xf];
+        }
 
-	restuple = Py_BuildValue("(On)", res, end);
-	Py_DECREF(res);
-	Py_DECREF(object);
-	return restuple;
+        restuple = Py_BuildValue("(On)", res, end);
+        Py_DECREF(res);
+        Py_DECREF(object);
+        return restuple;
     }
     else {
-	wrong_exception_type(exc);
-	return NULL;
+        wrong_exception_type(exc);
+        return NULL;
     }
 }
 #endif
@@ -765,63 +765,63 @@
 static int _PyCodecRegistry_Init(void)
 {
     static struct {
-	char *name;
-	PyMethodDef def;
+        char *name;
+        PyMethodDef def;
     } methods[] =
     {
-	{
-	    "strict",
-	    {
-		"strict_errors",
-		strict_errors,
-		METH_O,
-		PyDoc_STR("Implements the 'strict' error handling, which "
-			  "raises a UnicodeError on coding errors.")
-	    }
-	},
+        {
+            "strict",
+            {
+                "strict_errors",
+                strict_errors,
+                METH_O,
+                PyDoc_STR("Implements the 'strict' error handling, which "
+                          "raises a UnicodeError on coding errors.")
+            }
+        },
 #ifdef Py_USING_UNICODE
-	{
-	    "ignore",
-	    {
-		"ignore_errors",
-		ignore_errors,
-		METH_O,
-		PyDoc_STR("Implements the 'ignore' error handling, which "
-			  "ignores malformed data and continues.")
-	    }
-	},
-	{
-	    "replace",
-	    {
-		"replace_errors",
-		replace_errors,
-		METH_O,
-		PyDoc_STR("Implements the 'replace' error handling, which "
-			  "replaces malformed data with a replacement marker.")
-	    }
-	},
-	{
-	    "xmlcharrefreplace",
-	    {
-		"xmlcharrefreplace_errors",
-		xmlcharrefreplace_errors,
-		METH_O,
-		PyDoc_STR("Implements the 'xmlcharrefreplace' error handling, "
-			  "which replaces an unencodable character with the "
-			  "appropriate XML character reference.")
-	    }
-	},
-	{
-	    "backslashreplace",
-	    {
-		"backslashreplace_errors",
-		backslashreplace_errors,
-		METH_O,
-		PyDoc_STR("Implements the 'backslashreplace' error handling, "
-			  "which replaces an unencodable character with a "
-			  "backslashed escape sequence.")
-	    }
-	}
+        {
+            "ignore",
+            {
+                "ignore_errors",
+                ignore_errors,
+                METH_O,
+                PyDoc_STR("Implements the 'ignore' error handling, which "
+                          "ignores malformed data and continues.")
+            }
+        },
+        {
+            "replace",
+            {
+                "replace_errors",
+                replace_errors,
+                METH_O,
+                PyDoc_STR("Implements the 'replace' error handling, which "
+                          "replaces malformed data with a replacement marker.")
+            }
+        },
+        {
+            "xmlcharrefreplace",
+            {
+                "xmlcharrefreplace_errors",
+                xmlcharrefreplace_errors,
+                METH_O,
+                PyDoc_STR("Implements the 'xmlcharrefreplace' error handling, "
+                          "which replaces an unencodable character with the "
+                          "appropriate XML character reference.")
+            }
+        },
+        {
+            "backslashreplace",
+            {
+                "backslashreplace_errors",
+                backslashreplace_errors,
+                METH_O,
+                PyDoc_STR("Implements the 'backslashreplace' error handling, "
+                          "which replaces an unencodable character with a "
+                          "backslashed escape sequence.")
+            }
+        }
 #endif
     };
 
@@ -830,42 +830,42 @@
     unsigned i;
 
     if (interp->codec_search_path != NULL)
-	return 0;
+        return 0;
 
     interp->codec_search_path = PyList_New(0);
     interp->codec_search_cache = PyDict_New();
     interp->codec_error_registry = PyDict_New();
 
     if (interp->codec_error_registry) {
-	for (i = 0; i < sizeof(methods)/sizeof(methods[0]); ++i) {
-	    PyObject *func = PyCFunction_New(&methods[i].def, NULL);
-	    int res;
-	    if (!func)
-		Py_FatalError("can't initialize codec error registry");
-	    res = PyCodec_RegisterError(methods[i].name, func);
-	    Py_DECREF(func);
-	    if (res)
-		Py_FatalError("can't initialize codec error registry");
-	}
+        for (i = 0; i < sizeof(methods)/sizeof(methods[0]); ++i) {
+            PyObject *func = PyCFunction_New(&methods[i].def, NULL);
+            int res;
+            if (!func)
+                Py_FatalError("can't initialize codec error registry");
+            res = PyCodec_RegisterError(methods[i].name, func);
+            Py_DECREF(func);
+            if (res)
+                Py_FatalError("can't initialize codec error registry");
+        }
     }
 
     if (interp->codec_search_path == NULL ||
-	interp->codec_search_cache == NULL ||
-	interp->codec_error_registry == NULL)
-	Py_FatalError("can't initialize codec registry");
+        interp->codec_search_cache == NULL ||
+        interp->codec_error_registry == NULL)
+        Py_FatalError("can't initialize codec registry");
 
     mod = PyImport_ImportModuleLevel("encodings", NULL, NULL, NULL, 0);
     if (mod == NULL) {
-	if (PyErr_ExceptionMatches(PyExc_ImportError)) {
-	    /* Ignore ImportErrors... this is done so that
-	       distributions can disable the encodings package. Note
-	       that other errors are not masked, e.g. SystemErrors
-	       raised to inform the user of an error in the Python
-	       configuration are still reported back to the user. */
-	    PyErr_Clear();
-	    return 0;
-	}
-	return -1;
+        if (PyErr_ExceptionMatches(PyExc_ImportError)) {
+            /* Ignore ImportErrors... this is done so that
+               distributions can disable the encodings package. Note
+               that other errors are not masked, e.g. SystemErrors
+               raised to inform the user of an error in the Python
+               configuration are still reported back to the user. */
+            PyErr_Clear();
+            return 0;
+        }
+        return -1;
     }
     Py_DECREF(mod);
     return 0;